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-toolkit/devel-api/builder/builder.h>
 442
 443 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 444 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 445
 446 #include <dali-toolkit/devel-api/controls/control-devel.h>
 447 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 448 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 449 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 453 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 454
 455 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 456 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 457 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 458
 459 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 460 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 461 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 462
 463 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 464 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 465 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 466
 467 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 468
 469 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 470 #include <dali/devel-api/adaptor-framework/image-loading.h>
 471
 472 #include <dali/public-api/events/mouse-button.h>
 473
 474 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 475 #include "web-view-signal-converter.h"
 476
 477 #include <dali/integration-api/debug.h>
 478
 479 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 480
 481 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 482
 483
 484 // add here SWIG version check
 485
 486 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 487 // disable Swig-dependent warnings
 488
 489 // 'identifier1' has C-linkage specified,
 490 // but returns UDT 'identifier2' which is incompatible with C
 491 #pragma warning(disable: 4190)
 492
 493 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 494 #pragma warning(disable: 4800)
 495
 496 // debug info too long etc etc
 497 #pragma warning(disable: 4786)
 498 #endif
 499
 500
 501 #include <stdexcept>
 502
 503
 504 #include <string>
 505
 506
 507 #include <vector>
 508 #include <algorithm>
 509 #include <stdexcept>
 510
 511
 512 #include <map>
 513 #include <algorithm>
 514 #include <stdexcept>
 515
 516
 517 #include <utility>
 518
 519
 520 typedef float floatp;
 521
 522 SWIGINTERN floatp *new_floatp(){
 523   return new float();
 524 }
 525 SWIGINTERN void delete_floatp(floatp *self){
 526   if (self) delete self;
 527 }
 528 SWIGINTERN void floatp_assign(floatp *self,float value){
 529   *self = value;
 530 }
 531 SWIGINTERN float floatp_value(floatp *self){
 532   return *self;
 533 }
 534 SWIGINTERN float *floatp_cast(floatp *self){
 535   return self;
 536 }
 537 SWIGINTERN floatp *floatp_frompointer(float *t){
 538   return (floatp *) t;
 539 }
 540
 541 typedef int intp;
 542
 543 SWIGINTERN intp *new_intp(){
 544   return new int();
 545 }
 546 SWIGINTERN void delete_intp(intp *self){
 547   if (self) delete self;
 548 }
 549 SWIGINTERN void intp_assign(intp *self,int value){
 550   *self = value;
 551 }
 552 SWIGINTERN int intp_value(intp *self){
 553   return *self;
 554 }
 555 SWIGINTERN int *intp_cast(intp *self){
 556   return self;
 557 }
 558 SWIGINTERN intp *intp_frompointer(int *t){
 559   return (intp *) t;
 560 }
 561
 562 typedef double doublep;
 563
 564 SWIGINTERN doublep *new_doublep(){
 565   return new double();
 566 }
 567 SWIGINTERN void delete_doublep(doublep *self){
 568   if (self) delete self;
 569 }
 570 SWIGINTERN void doublep_assign(doublep *self,double value){
 571   *self = value;
 572 }
 573 SWIGINTERN double doublep_value(doublep *self){
 574   return *self;
 575 }
 576 SWIGINTERN double *doublep_cast(doublep *self){
 577   return self;
 578 }
 579 SWIGINTERN doublep *doublep_frompointer(double *t){
 580   return (doublep *) t;
 581 }
 582
 583 typedef unsigned int uintp;
 584
 585 SWIGINTERN uintp *new_uintp(){
 586   return new unsigned int();
 587 }
 588 SWIGINTERN void delete_uintp(uintp *self){
 589   if (self) delete self;
 590 }
 591 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 592   *self = value;
 593 }
 594 SWIGINTERN unsigned int uintp_value(uintp *self){
 595   return *self;
 596 }
 597 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 598   return self;
 599 }
 600 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 601   return (uintp *) t;
 602 }
 603
 604 typedef unsigned short ushortp;
 605
 606 SWIGINTERN ushortp *new_ushortp(){
 607   return new unsigned short();
 608 }
 609 SWIGINTERN void delete_ushortp(ushortp *self){
 610   if (self) delete self;
 611 }
 612 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 613   *self = value;
 614 }
 615 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 616   return *self;
 617 }
 618 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 619   return self;
 620 }
 621 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 622   return (ushortp *) t;
 623 }
 624
 625 unsigned int int_to_uint(int x) {
 626    return (unsigned int) x;
 627 }
 628
 629
 630 using namespace Dali;
 631 using namespace Dali::Toolkit;
 632
 633 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 634 {
 635   bool result = false;
 636   try
 637   {
 638     // C++ code. DALi uses Handle <-> Body design pattern.
 639     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 640     // Handles in DALi can be converted into a boolean type
 641     // to check if the handle has a valid body attached to it.
 642     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 643     if( *self )
 644     {
 645       result = true;
 646     }
 647     else
 648     {
 649       result = false;
 650     }
 651   }
 652   catch (std::out_of_range& e)
 653   {
 654     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 655     return 0;
 656   }
 657   catch (std::exception& e)
 658   {
 659     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 660     return 0;
 661   }
 662   catch (DaliException e)
 663   {
 664     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 665     return 0;
 666   }
 667   catch (...)
 668   {
 669     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 670     return 0;
 671   }
 672   return result;
 673 }
 674
 675 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 676 {
 677   bool result = false;
 678   try
 679   {
 680     // C++ code. Check if two handles reference the same implemtion
 681     if( *self == rhs)
 682     {
 683       result = true;
 684     }
 685     else
 686     {
 687       result = false;
 688     }
 689   }
 690   catch (std::out_of_range& e)
 691   {
 692     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 693     return 0;
 694   }
 695   catch (std::exception& e)
 696   {
 697     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 698     return 0;
 699   }
 700   catch (DaliException e)
 701   {
 702     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 703     return 0;
 704   }
 705   catch (...)
 706   {
 707     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 708     return 0;
 709   }
 710   return result;
 711 }
 712
 713
 714 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 715      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 716    }
 717 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){
 718      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 719    }
 720 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 721         std::vector< Dali::TouchPoint >* pv = 0;
 722         if (capacity >= 0) {
 723           pv = new std::vector< Dali::TouchPoint >();
 724           pv->reserve(capacity);
 725        } else {
 726           throw std::out_of_range("capacity");
 727        }
 728        return pv;
 729       }
 730 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 731         if (index>=0 && index<(int)self->size())
 732           return (*self)[index];
 733         else
 734           throw std::out_of_range("index");
 735       }
 736 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 737         if (index>=0 && index<(int)self->size())
 738           return (*self)[index];
 739         else
 740           throw std::out_of_range("index");
 741       }
 742 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 743         if (index>=0 && index<(int)self->size())
 744           (*self)[index] = val;
 745         else
 746           throw std::out_of_range("index");
 747       }
 748 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 749         self->insert(self->end(), values.begin(), values.end());
 750       }
 751 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 752         if (index < 0)
 753           throw std::out_of_range("index");
 754         if (count < 0)
 755           throw std::out_of_range("count");
 756         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 757           throw std::invalid_argument("invalid range");
 758         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 759       }
 760 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 761         if (index>=0 && index<(int)self->size()+1)
 762           self->insert(self->begin()+index, x);
 763         else
 764           throw std::out_of_range("index");
 765       }
 766 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 767         if (index>=0 && index<(int)self->size()+1)
 768           self->insert(self->begin()+index, values.begin(), values.end());
 769         else
 770           throw std::out_of_range("index");
 771       }
 772 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 773         if (index>=0 && index<(int)self->size())
 774           self->erase(self->begin() + index);
 775         else
 776           throw std::out_of_range("index");
 777       }
 778 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 779         if (index < 0)
 780           throw std::out_of_range("index");
 781         if (count < 0)
 782           throw std::out_of_range("count");
 783         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 784           throw std::invalid_argument("invalid range");
 785         self->erase(self->begin()+index, self->begin()+index+count);
 786       }
 787 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 788         if (count < 0)
 789           throw std::out_of_range("count");
 790         return new std::vector< Dali::TouchPoint >(count, value);
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 793         std::reverse(self->begin(), self->end());
 794       }
 795 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 796         if (index < 0)
 797           throw std::out_of_range("index");
 798         if (count < 0)
 799           throw std::out_of_range("count");
 800         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 801           throw std::invalid_argument("invalid range");
 802         std::reverse(self->begin()+index, self->begin()+index+count);
 803       }
 804 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 805         if (index < 0)
 806           throw std::out_of_range("index");
 807         if (index+values.size() > self->size())
 808           throw std::out_of_range("index");
 809         std::copy(values.begin(), values.end(), self->begin()+index);
 810       }
 811 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 812          return self->Empty();
 813       }
 814 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 815         return self->GetConnectionCount();
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 818           self->Connect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 821           self->Disconnect( func );
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 824           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 825 /*@SWIG@*/ self->Emit( arg );
 826       }
 827 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 828          return self->Empty();
 829       }
 830 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 831         return self->GetConnectionCount();
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 834           self->Connect( func );
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 837           self->Disconnect( func );
 838       }
 839 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 840           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 841 /*@SWIG@*/ self->Emit( arg );
 842       }
 843 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 844          return self->Empty();
 845       }
 846 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){
 847         return self->GetConnectionCount();
 848       }
 849 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 *)){
 850           self->Connect( func );
 851       }
 852 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 *)){
 853           self->Disconnect( func );
 854       }
 855 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){
 856           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 857 /*@SWIG@*/ self->Emit( arg );
 858       }
 859 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 860          return self->Empty();
 861       }
 862 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 863         return self->GetConnectionCount();
 864       }
 865 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 866           self->Connect( func );
 867       }
 868 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 869           self->Disconnect( func );
 870       }
 871 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 872           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 873 /*@SWIG@*/ self->Emit( arg );
 874       }
 875 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){
 876          return self->Empty();
 877       }
 878 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){
 879         return self->GetConnectionCount();
 880       }
 881 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 &)){
 882         self->Connect( func );
 883       }
 884 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 &)){
 885         self->Disconnect( func );
 886       }
 887 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){
 888         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 889 /*@SWIG@*/ self->Emit( arg1, arg2 );
 890       }
 891 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){
 892          return self->Empty();
 893       }
 894 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){
 895         return self->GetConnectionCount();
 896       }
 897 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 &)){
 898         self->Connect( func );
 899       }
 900 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 &)){
 901         self->Disconnect( func );
 902       }
 903 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){
 904         return self->Emit( arg1, arg2 );
 905       }
 906 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){
 907          return self->Empty();
 908       }
 909 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){
 910         return self->GetConnectionCount();
 911       }
 912 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 &)){
 913         self->Connect( func );
 914       }
 915 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 &)){
 916         self->Disconnect( func );
 917       }
 918 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){
 919         return self->Emit( arg1, arg2 );
 920       }
 921 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){
 922          return self->Empty();
 923       }
 924 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){
 925         return self->GetConnectionCount();
 926       }
 927 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 &)){
 928         self->Connect( func );
 929       }
 930 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 &)){
 931         self->Disconnect( func );
 932       }
 933 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){
 934         return self->Emit( arg1, arg2 );
 935       }
 936 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 937          return self->Empty();
 938       }
 939 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 940         return self->GetConnectionCount();
 941       }
 942 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 943           self->Connect( func );
 944       }
 945 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 946           self->Disconnect( func );
 947       }
 948 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 949           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 950 /*@SWIG@*/ self->Emit( arg );
 951       }
 952 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 953          return self->Empty();
 954       }
 955 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){
 956         return self->GetConnectionCount();
 957       }
 958 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 &)){
 959           self->Connect( func );
 960       }
 961 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 &)){
 962           self->Disconnect( func );
 963       }
 964 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){
 965           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 966 /*@SWIG@*/ self->Emit( arg );
 967       }
 968 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 969          return self->Empty();
 970       }
 971 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){
 972         return self->GetConnectionCount();
 973       }
 974 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 &)){
 975           self->Connect( func );
 976       }
 977 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 &)){
 978           self->Disconnect( func );
 979       }
 980 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){
 981           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 982 /*@SWIG@*/ self->Emit( arg );
 983       }
 984 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 985          return self->Empty();
 986       }
 987 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){
 988         return self->GetConnectionCount();
 989       }
 990 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 &)){
 991           self->Connect( func );
 992       }
 993 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 &)){
 994           self->Disconnect( func );
 995       }
 996 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){
 997           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 998 /*@SWIG@*/ self->Emit( arg );
 999       }
1000 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){
1001          return self->Empty();
1002       }
1003 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){
1004         return self->GetConnectionCount();
1005       }
1006 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 &)){
1007         self->Connect( func );
1008       }
1009 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 &)){
1010         self->Disconnect( func );
1011       }
1012 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){
1013         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1014 /*@SWIG@*/ self->Emit( arg1, arg2 );
1015       }
1016 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){
1017          return self->Empty();
1018       }
1019 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){
1020         return self->GetConnectionCount();
1021       }
1022 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 &)){
1023         self->Connect( func );
1024       }
1025 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 &)){
1026         self->Disconnect( func );
1027       }
1028 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){
1029         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1030 /*@SWIG@*/ self->Emit( arg1, arg2 );
1031       }
1032 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){
1033          return self->Empty();
1034       }
1035 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){
1036         return self->GetConnectionCount();
1037       }
1038 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 &)){
1039         self->Connect( func );
1040       }
1041 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 &)){
1042         self->Disconnect( func );
1043       }
1044 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){
1045         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1046 /*@SWIG@*/ self->Emit( arg1, arg2 );
1047       }
1048 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1049          return self->Empty();
1050       }
1051 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1052         return self->GetConnectionCount();
1053       }
1054 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1055           self->Connect( func );
1056       }
1057 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1058           self->Disconnect( func );
1059       }
1060 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1061           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1062 /*@SWIG@*/ self->Emit( arg );
1063       }
1064 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){
1065          return self->Empty();
1066       }
1067 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){
1068         return self->GetConnectionCount();
1069       }
1070 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)){
1071           return self->Connect( func );
1072       }
1073 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)){
1074           self->Disconnect( func );
1075       }
1076 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){
1077           self->Emit( arg1, arg3 );
1078       }
1079 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){
1080          return self->Empty();
1081       }
1082 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){
1083         return self->GetConnectionCount();
1084       }
1085 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)){
1086           return self->Connect( func );
1087       }
1088 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)){
1089           self->Disconnect( func );
1090       }
1091 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){
1092           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1093 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1094       }
1095
1096 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1097          return self->Empty();
1098       }
1099 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1100         return self->GetConnectionCount();
1101       }
1102 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1103           self->Connect( func );
1104       }
1105 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1106           self->Disconnect( func );
1107       }
1108 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1109           return self->Emit();
1110       }
1111
1112 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1113         std::vector< unsigned int >* pv = 0;
1114         if (capacity >= 0) {
1115           pv = new std::vector< unsigned int >();
1116           pv->reserve(capacity);
1117        } else {
1118           throw std::out_of_range("capacity");
1119        }
1120        return pv;
1121       }
1122 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1123         if (index>=0 && index<(int)self->size())
1124           return (*self)[index];
1125         else
1126           throw std::out_of_range("index");
1127       }
1128 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1129         if (index>=0 && index<(int)self->size())
1130           return (*self)[index];
1131         else
1132           throw std::out_of_range("index");
1133       }
1134 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1135         if (index>=0 && index<(int)self->size())
1136           (*self)[index] = val;
1137         else
1138           throw std::out_of_range("index");
1139       }
1140 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1141         self->insert(self->end(), values.begin(), values.end());
1142       }
1143 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1144         if (index < 0)
1145           throw std::out_of_range("index");
1146         if (count < 0)
1147           throw std::out_of_range("count");
1148         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1149           throw std::invalid_argument("invalid range");
1150         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1151       }
1152 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1153         if (index>=0 && index<(int)self->size()+1)
1154           self->insert(self->begin()+index, x);
1155         else
1156           throw std::out_of_range("index");
1157       }
1158 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1159         if (index>=0 && index<(int)self->size()+1)
1160           self->insert(self->begin()+index, values.begin(), values.end());
1161         else
1162           throw std::out_of_range("index");
1163       }
1164 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1165         if (index>=0 && index<(int)self->size())
1166           self->erase(self->begin() + index);
1167         else
1168           throw std::out_of_range("index");
1169       }
1170 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1171         if (index < 0)
1172           throw std::out_of_range("index");
1173         if (count < 0)
1174           throw std::out_of_range("count");
1175         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1176           throw std::invalid_argument("invalid range");
1177         self->erase(self->begin()+index, self->begin()+index+count);
1178       }
1179 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1180         if (count < 0)
1181           throw std::out_of_range("count");
1182         return new std::vector< unsigned int >(count, value);
1183       }
1184 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1185         std::reverse(self->begin(), self->end());
1186       }
1187 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1188         if (index < 0)
1189           throw std::out_of_range("index");
1190         if (count < 0)
1191           throw std::out_of_range("count");
1192         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1193           throw std::invalid_argument("invalid range");
1194         std::reverse(self->begin()+index, self->begin()+index+count);
1195       }
1196 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1197         if (index < 0)
1198           throw std::out_of_range("index");
1199         if (index+values.size() > self->size())
1200           throw std::out_of_range("index");
1201         std::copy(values.begin(), values.end(), self->begin()+index);
1202       }
1203 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1204         return std::find(self->begin(), self->end(), value) != self->end();
1205       }
1206 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1207         int index = -1;
1208         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1209         if (it != self->end())
1210           index = (int)(it - self->begin());
1211         return index;
1212       }
1213 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1214         int index = -1;
1215         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1216         if (rit != self->rend())
1217           index = (int)(self->rend() - 1 - rit);
1218         return index;
1219       }
1220 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1221         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1222         if (it != self->end()) {
1223           self->erase(it);
1224           return true;
1225         }
1226         return false;
1227       }
1228 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){
1229         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1230         if (capacity >= 0) {
1231           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1232           pv->reserve(capacity);
1233        } else {
1234           throw std::out_of_range("capacity");
1235        }
1236        return pv;
1237       }
1238 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){
1239         if (index>=0 && index<(int)self->size())
1240           return (*self)[index];
1241         else
1242           throw std::out_of_range("index");
1243       }
1244 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){
1245         if (index>=0 && index<(int)self->size())
1246           return (*self)[index];
1247         else
1248           throw std::out_of_range("index");
1249       }
1250 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){
1251         if (index>=0 && index<(int)self->size())
1252           (*self)[index] = val;
1253         else
1254           throw std::out_of_range("index");
1255       }
1256 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1257         self->insert(self->end(), values.begin(), values.end());
1258       }
1259 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){
1260         if (index < 0)
1261           throw std::out_of_range("index");
1262         if (count < 0)
1263           throw std::out_of_range("count");
1264         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1265           throw std::invalid_argument("invalid range");
1266         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1267       }
1268 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){
1269         if (index>=0 && index<(int)self->size()+1)
1270           self->insert(self->begin()+index, x);
1271         else
1272           throw std::out_of_range("index");
1273       }
1274 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){
1275         if (index>=0 && index<(int)self->size()+1)
1276           self->insert(self->begin()+index, values.begin(), values.end());
1277         else
1278           throw std::out_of_range("index");
1279       }
1280 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1281         if (index>=0 && index<(int)self->size())
1282           self->erase(self->begin() + index);
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__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1287         if (index < 0)
1288           throw std::out_of_range("index");
1289         if (count < 0)
1290           throw std::out_of_range("count");
1291         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1292           throw std::invalid_argument("invalid range");
1293         self->erase(self->begin()+index, self->begin()+index+count);
1294       }
1295 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){
1296         if (count < 0)
1297           throw std::out_of_range("count");
1298         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1299       }
1300 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){
1301         std::reverse(self->begin(), self->end());
1302       }
1303 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){
1304         if (index < 0)
1305           throw std::out_of_range("index");
1306         if (count < 0)
1307           throw std::out_of_range("count");
1308         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1309           throw std::invalid_argument("invalid range");
1310         std::reverse(self->begin()+index, self->begin()+index+count);
1311       }
1312 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){
1313         if (index < 0)
1314           throw std::out_of_range("index");
1315         if (index+values.size() > self->size())
1316           throw std::out_of_range("index");
1317         std::copy(values.begin(), values.end(), self->begin()+index);
1318       }
1319 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1320         std::vector< Dali::Actor >* pv = 0;
1321         if (capacity >= 0) {
1322           pv = new std::vector< Dali::Actor >();
1323           pv->reserve(capacity);
1324        } else {
1325           throw std::out_of_range("capacity");
1326        }
1327        return pv;
1328       }
1329 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1330         if (index>=0 && index<(int)self->size())
1331           return (*self)[index];
1332         else
1333           throw std::out_of_range("index");
1334       }
1335 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1336         if (index>=0 && index<(int)self->size())
1337           return (*self)[index];
1338         else
1339           throw std::out_of_range("index");
1340       }
1341 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1342         if (index>=0 && index<(int)self->size())
1343           (*self)[index] = val;
1344         else
1345           throw std::out_of_range("index");
1346       }
1347 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1348         self->insert(self->end(), values.begin(), values.end());
1349       }
1350 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1351         if (index < 0)
1352           throw std::out_of_range("index");
1353         if (count < 0)
1354           throw std::out_of_range("count");
1355         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1356           throw std::invalid_argument("invalid range");
1357         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1358       }
1359 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1360         if (index>=0 && index<(int)self->size()+1)
1361           self->insert(self->begin()+index, x);
1362         else
1363           throw std::out_of_range("index");
1364       }
1365 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1366         if (index>=0 && index<(int)self->size()+1)
1367           self->insert(self->begin()+index, values.begin(), values.end());
1368         else
1369           throw std::out_of_range("index");
1370       }
1371 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1372         if (index>=0 && index<(int)self->size())
1373           self->erase(self->begin() + index);
1374         else
1375           throw std::out_of_range("index");
1376       }
1377 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1378         if (index < 0)
1379           throw std::out_of_range("index");
1380         if (count < 0)
1381           throw std::out_of_range("count");
1382         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1383           throw std::invalid_argument("invalid range");
1384         self->erase(self->begin()+index, self->begin()+index+count);
1385       }
1386 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1387         if (count < 0)
1388           throw std::out_of_range("count");
1389         return new std::vector< Dali::Actor >(count, value);
1390       }
1391 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1392         std::reverse(self->begin(), self->end());
1393       }
1394 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1395         if (index < 0)
1396           throw std::out_of_range("index");
1397         if (count < 0)
1398           throw std::out_of_range("count");
1399         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1400           throw std::invalid_argument("invalid range");
1401         std::reverse(self->begin()+index, self->begin()+index+count);
1402       }
1403 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1404         if (index < 0)
1405           throw std::out_of_range("index");
1406         if (index+values.size() > self->size())
1407           throw std::out_of_range("index");
1408         std::copy(values.begin(), values.end(), self->begin()+index);
1409       }
1410 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1411          return self->Empty();
1412       }
1413 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1414         return self->GetConnectionCount();
1415       }
1416 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 &)){
1417           self->Connect( func );
1418       }
1419 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 &)){
1420           self->Disconnect( func );
1421       }
1422 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){
1423           return self->Emit( arg );
1424       }
1425 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){
1426          return self->Empty();
1427       }
1428 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){
1429         return self->GetConnectionCount();
1430       }
1431 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)){
1432         self->Connect( func );
1433       }
1434 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)){
1435         self->Disconnect( func );
1436       }
1437 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){
1438         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1439 /*@SWIG@*/ self->Emit( arg1, arg2 );
1440       }
1441 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1442          return self->Empty();
1443       }
1444 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){
1445         return self->GetConnectionCount();
1446       }
1447 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)){
1448         self->Connect( func );
1449       }
1450 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)){
1451         self->Disconnect( func );
1452       }
1453 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){
1454         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1455 /*@SWIG@*/ self->Emit( arg1, arg2 );
1456       }
1457 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1458          return self->Empty();
1459       }
1460 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1461         return self->GetConnectionCount();
1462       }
1463 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)){
1464         self->Connect( func );
1465       }
1466 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)){
1467         self->Disconnect( func );
1468       }
1469 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){
1470         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1471 /*@SWIG@*/ self->Emit( arg1, arg2 );
1472       }
1473 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){
1474          return self->Empty();
1475       }
1476 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){
1477         return self->GetConnectionCount();
1478       }
1479 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)){
1480         self->Connect( func );
1481       }
1482 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)){
1483         self->Disconnect( func );
1484       }
1485 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){
1486         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1487 /*@SWIG@*/ self->Emit( arg1, arg2 );
1488       }
1489 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1490          return self->Empty();
1491       }
1492 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1493         return self->GetConnectionCount();
1494       }
1495 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)){
1496           self->Connect( func );
1497       }
1498 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)){
1499           self->Disconnect( func );
1500       }
1501 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1502           return self->Emit( arg );
1503       }
1504 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1505          return self->Empty();
1506       }
1507 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1508         return self->GetConnectionCount();
1509       }
1510 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)){
1511           self->Connect( func );
1512       }
1513 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)){
1514           self->Disconnect( func );
1515       }
1516 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1517           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1518 /*@SWIG@*/ self->Emit( arg );
1519       }
1520 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){
1521          return self->Empty();
1522       }
1523 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){
1524         return self->GetConnectionCount();
1525       }
1526 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)){
1527           return self->Connect( func );
1528       }
1529 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)){
1530           self->Disconnect( func );
1531       }
1532 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){
1533           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1534 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1535       }
1536 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1537          return self->Empty();
1538       }
1539 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1540         return self->GetConnectionCount();
1541       }
1542 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)){
1543           self->Connect( func );
1544       }
1545 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)){
1546           self->Disconnect( func );
1547       }
1548 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1549           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1550 /*@SWIG@*/ self->Emit( arg );
1551       }
1552 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){
1553          return self->Empty();
1554       }
1555 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){
1556         return self->GetConnectionCount();
1557       }
1558 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)){
1559           return self->Connect( func );
1560       }
1561 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)){
1562           self->Disconnect( func );
1563       }
1564 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){
1565           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1566 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1567       }
1568 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){
1569          return self->Empty();
1570       }
1571 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){
1572         return self->GetConnectionCount();
1573       }
1574 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 &)){
1575           self->Connect( func );
1576       }
1577 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 &)){
1578           self->Disconnect( func );
1579       }
1580 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){
1581           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1582 /*@SWIG@*/ self->Emit( arg );
1583       }
1584 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1585          return self->Empty();
1586       }
1587 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){
1588         return self->GetConnectionCount();
1589       }
1590 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 &)){
1591           self->Connect( func );
1592       }
1593 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 &)){
1594           self->Disconnect( func );
1595       }
1596 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){
1597           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1598 /*@SWIG@*/ self->Emit( arg );
1599       }
1600
1601
1602 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){
1603          return self->Empty();
1604       }
1605 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){
1606         return self->GetConnectionCount();
1607       }
1608 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 &)){
1609         self->Connect( func );
1610       }
1611 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 &)){
1612         self->Disconnect( func );
1613       }
1614 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){
1615         return self->Emit( arg1, arg2 );
1616       }
1617 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1618          return self->Empty();
1619       }
1620 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1621         return self->GetConnectionCount();
1622       }
1623 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)){
1624           self->Connect( func );
1625       }
1626 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)){
1627           self->Disconnect( func );
1628       }
1629 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1630           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1631 /*@SWIG@*/ self->Emit( arg );
1632       }
1633 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1634          return self->Empty();
1635       }
1636 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1637         return self->GetConnectionCount();
1638       }
1639 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 &)){
1640           self->Connect( func );
1641       }
1642 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 &)){
1643           self->Disconnect( func );
1644       }
1645 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){
1646           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1647 /*@SWIG@*/ self->Emit( arg );
1648       }
1649 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1650          return self->Empty();
1651       }
1652 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){
1653         return self->GetConnectionCount();
1654       }
1655 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)){
1656         self->Connect( func );
1657       }
1658 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)){
1659         self->Disconnect( func );
1660       }
1661 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){
1662         return self->Emit( arg1, arg2 );
1663       }
1664 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1665          return self->Empty();
1666       }
1667 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){
1668         return self->GetConnectionCount();
1669       }
1670 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)){
1671         self->Connect( func );
1672       }
1673 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)){
1674         self->Disconnect( func );
1675       }
1676 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){
1677         return self->Emit( arg1, arg2 );
1678       }
1679
1680 /* ---------------------------------------------------
1681  * C++ director class methods
1682  * --------------------------------------------------- */
1683
1684 #include "dali_wrap.h"
1685
1686 /*
1687  *  Widget director
1688  */
1689 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1690   swig_init_callbacks();
1691 }
1692
1693 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1694 }
1695
1696 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1697   char * jcontentInfo = 0 ;
1698   void * jwindow  ;
1699
1700   if (!swig_callbackOnCreate) {
1701     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1702     return;
1703   } else {
1704     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1705     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1706     swig_callbackOnCreate(jcontentInfo, jwindow);
1707   }
1708 }
1709
1710 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1711   char * jcontentInfo = 0 ;
1712   int jtype  ;
1713
1714   if (!swig_callbackOnTerminate) {
1715     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1716     return;
1717   } else {
1718     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1719     jtype = (int)type;
1720     swig_callbackOnTerminate(jcontentInfo, jtype);
1721   }
1722 }
1723
1724 void SwigDirector_WidgetImpl::OnPause() {
1725   if (!swig_callbackOnPause) {
1726     Dali::Internal::Adaptor::Widget::OnPause();
1727     return;
1728   } else {
1729     swig_callbackOnPause();
1730   }
1731 }
1732
1733 void SwigDirector_WidgetImpl::OnResume() {
1734   if (!swig_callbackOnResume) {
1735     Dali::Internal::Adaptor::Widget::OnResume();
1736     return;
1737   } else {
1738     swig_callbackOnResume();
1739   }
1740 }
1741
1742 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1743   void * jwindow  ;
1744
1745   if (!swig_callbackOnResize) {
1746     Dali::Internal::Adaptor::Widget::OnResize(window);
1747     return;
1748   } else {
1749     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1750     swig_callbackOnResize(jwindow);
1751   }
1752 }
1753
1754 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1755   char * jcontentInfo = 0 ;
1756   int jforce  ;
1757
1758   if (!swig_callbackOnUpdate) {
1759     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1760     return;
1761   } else {
1762     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1763     jforce = force;
1764     swig_callbackOnUpdate(jcontentInfo, jforce);
1765   }
1766 }
1767
1768 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1769   void * jslotObserver = 0 ;
1770   void * jcallback = 0 ;
1771
1772   if (!swig_callbackSignalConnected) {
1773     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1774     return;
1775   } else {
1776     jslotObserver = (void *) slotObserver;
1777     jcallback = (void *) callback;
1778     swig_callbackSignalConnected(jslotObserver, jcallback);
1779   }
1780 }
1781
1782 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1783   void * jslotObserver = 0 ;
1784   void * jcallback = 0 ;
1785
1786   if (!swig_callbackSignalDisconnected) {
1787     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1788     return;
1789   } else {
1790     jslotObserver = (void *) slotObserver;
1791     jcallback = (void *) callback;
1792     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1793   }
1794 }
1795
1796 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) {
1797
1798   swig_callbackOnCreate = callbackOnCreate;
1799   swig_callbackOnTerminate = callbackOnTerminate;
1800   swig_callbackOnPause = callbackOnPause;
1801   swig_callbackOnResume = callbackOnResume;
1802   swig_callbackOnResize = callbackOnResize;
1803   swig_callbackOnUpdate = callbackOnUpdate;
1804   swig_callbackSignalConnected = callbackSignalConnected;
1805   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1806 }
1807
1808 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1809   swig_callbackOnCreate = 0;
1810   swig_callbackOnTerminate = 0;
1811   swig_callbackOnPause = 0;
1812   swig_callbackOnResume = 0;
1813   swig_callbackOnResize = 0;
1814   swig_callbackOnUpdate = 0;
1815   swig_callbackSignalConnected = 0;
1816   swig_callbackSignalDisconnected = 0;
1817 }
1818
1819
1820 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1821   swig_init_callbacks();
1822 }
1823
1824 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1825
1826 }
1827
1828
1829 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1830   int jdepth  ;
1831
1832   if (!swig_callbackOnStageConnection) {
1833     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1834     return;
1835   } else {
1836     jdepth = depth;
1837     swig_callbackOnStageConnection(jdepth);
1838   }
1839 }
1840
1841 void SwigDirector_ViewImpl::OnStageDisconnection() {
1842   if (!swig_callbackOnStageDisconnection) {
1843     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1844     return;
1845   } else {
1846     swig_callbackOnStageDisconnection();
1847   }
1848 }
1849
1850 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1851   void * jchild = 0 ;
1852
1853   if (!swig_callbackOnChildAdd) {
1854     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1855     return;
1856   } else {
1857     jchild = (Dali::Actor *) &child;
1858     swig_callbackOnChildAdd(jchild);
1859   }
1860 }
1861
1862 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1863   void * jchild = 0 ;
1864
1865   if (!swig_callbackOnChildRemove) {
1866     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1867     return;
1868   } else {
1869     jchild = (Dali::Actor *) &child;
1870     swig_callbackOnChildRemove(jchild);
1871   }
1872 }
1873
1874 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1875   int jindex  ;
1876   void * jpropertyValue  ;
1877
1878   if (!swig_callbackOnPropertySet) {
1879     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1880     return;
1881   } else {
1882     jindex = index;
1883     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1884     swig_callbackOnPropertySet(jindex, jpropertyValue);
1885   }
1886 }
1887
1888 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1889   void * jtargetSize = 0 ;
1890
1891   if (!swig_callbackOnSizeSet) {
1892     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1893     return;
1894   } else {
1895     jtargetSize = (Dali::Vector3 *) &targetSize;
1896     swig_callbackOnSizeSet(jtargetSize);
1897   }
1898 }
1899
1900 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1901   void * janimation = 0 ;
1902   void * jtargetSize = 0 ;
1903
1904   if (!swig_callbackOnSizeAnimation) {
1905     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1906     return;
1907   } else {
1908     janimation = (Dali::Animation *) &animation;
1909     jtargetSize = (Dali::Vector3 *) &targetSize;
1910     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1911   }
1912 }
1913
1914 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1915   bool c_result = SwigValueInit< bool >() ;
1916   unsigned int jresult = 0 ;
1917   void * jarg0 = 0 ;
1918
1919   if (!swig_callbackOnTouchEvent) {
1920     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1921   } else {
1922     jarg0 = (Dali::TouchEvent *) &event;
1923     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1924     c_result = jresult ? true : false;
1925   }
1926   return c_result;
1927 }
1928
1929 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1930   bool c_result = SwigValueInit< bool >() ;
1931   unsigned int jresult = 0 ;
1932   void * jarg0 = 0 ;
1933
1934   if (!swig_callbackOnHoverEvent) {
1935     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1936   } else {
1937     jarg0 = (Dali::HoverEvent *) &event;
1938     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1939     c_result = jresult ? true : false;
1940   }
1941   return c_result;
1942 }
1943
1944 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1945   bool c_result = SwigValueInit< bool >() ;
1946   unsigned int jresult = 0 ;
1947   void * jarg0 = 0 ;
1948
1949   if (!swig_callbackOnKeyEvent) {
1950     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1951   } else {
1952     jarg0 = (Dali::KeyEvent *) &event;
1953     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1954     c_result = jresult ? true : false;
1955   }
1956   return c_result;
1957 }
1958
1959 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1960   bool c_result = SwigValueInit< bool >() ;
1961   unsigned int jresult = 0 ;
1962   void * jarg0 = 0 ;
1963
1964   if (!swig_callbackOnWheelEvent) {
1965     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1966   } else {
1967     jarg0 = (Dali::WheelEvent *) &event;
1968     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1969     c_result = jresult ? true : false;
1970   }
1971   return c_result;
1972 }
1973
1974 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1975   void * jsize = 0 ;
1976   void * jcontainer = 0 ;
1977
1978   if (!swig_callbackOnRelayout) {
1979     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1980     return;
1981   } else {
1982     jsize = (Dali::Vector2 *) &size;
1983     jcontainer = (Dali::RelayoutContainer *) &container;
1984     swig_callbackOnRelayout(jsize, jcontainer);
1985   }
1986 }
1987
1988 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1989   int jpolicy  ;
1990   int jdimension  ;
1991
1992   if (!swig_callbackOnSetResizePolicy) {
1993     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1994     return;
1995   } else {
1996     jpolicy = (int)policy;
1997     jdimension = (int)dimension;
1998     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1999   }
2000 }
2001
2002 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2003   Dali::Vector3 c_result ;
2004   void * jresult = 0 ;
2005
2006   if (!swig_callbackGetNaturalSize) {
2007     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2008   } else {
2009     jresult = (void *) swig_callbackGetNaturalSize();
2010     if (!jresult) {
2011       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2012       return c_result;
2013     }
2014     c_result = *(Dali::Vector3 *)jresult;
2015   }
2016   return c_result;
2017 }
2018
2019 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2020   float c_result = SwigValueInit< float >() ;
2021   float jresult = 0 ;
2022   void * jchild = 0 ;
2023   int jdimension  ;
2024
2025   if (!swig_callbackCalculateChildSize) {
2026     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2027   } else {
2028     jchild = (Dali::Actor *) &child;
2029     jdimension = (int)dimension;
2030     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2031     c_result = (float)jresult;
2032   }
2033   return c_result;
2034 }
2035
2036 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2037   float c_result = SwigValueInit< float >() ;
2038   float jresult = 0 ;
2039   float jwidth  ;
2040
2041   if (!swig_callbackGetHeightForWidth) {
2042     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2043   } else {
2044     jwidth = width;
2045     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2046     c_result = (float)jresult;
2047   }
2048   return c_result;
2049 }
2050
2051 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2052   float c_result = SwigValueInit< float >() ;
2053   float jresult = 0 ;
2054   float jheight  ;
2055
2056   if (!swig_callbackGetWidthForHeight) {
2057     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2058   } else {
2059     jheight = height;
2060     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2061     c_result = (float)jresult;
2062   }
2063   return c_result;
2064 }
2065
2066 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2067   bool c_result = SwigValueInit< bool >() ;
2068   unsigned int jresult = 0 ;
2069   int jdimension  ;
2070
2071   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2072     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2073   } else {
2074     jdimension = (int)dimension;
2075     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2076     c_result = jresult ? true : false;
2077   }
2078   return c_result;
2079 }
2080
2081 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2082   int jdimension  ;
2083
2084   if (!swig_callbackOnCalculateRelayoutSize) {
2085     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2086     return;
2087   } else {
2088     jdimension = (int)dimension;
2089     swig_callbackOnCalculateRelayoutSize(jdimension);
2090   }
2091 }
2092
2093 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2094   float jsize  ;
2095   int jdimension  ;
2096
2097   if (!swig_callbackOnLayoutNegotiated) {
2098     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2099     return;
2100   } else {
2101     jsize = size;
2102     jdimension = (int)dimension;
2103     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2104   }
2105 }
2106
2107 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2108   return Dali::CustomActorImpl::GetExtension();
2109 }
2110
2111 void SwigDirector_ViewImpl::OnInitialize() {
2112   if (!swig_callbackOnInitialize) {
2113     Dali::Toolkit::Internal::Control::OnInitialize();
2114     return;
2115   } else {
2116     swig_callbackOnInitialize();
2117   }
2118 }
2119
2120 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2121   void * jchild = 0 ;
2122
2123   if (!swig_callbackOnControlChildAdd) {
2124     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2125     return;
2126   } else {
2127     jchild = (Dali::Actor *) &child;
2128     swig_callbackOnControlChildAdd(jchild);
2129   }
2130 }
2131
2132 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2133   void * jchild = 0 ;
2134
2135   if (!swig_callbackOnControlChildRemove) {
2136     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2137     return;
2138   } else {
2139     jchild = (Dali::Actor *) &child;
2140     swig_callbackOnControlChildRemove(jchild);
2141   }
2142 }
2143
2144 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2145   void * jstyleManager  ;
2146   int jchange  ;
2147
2148   if (!swig_callbackOnStyleChange) {
2149     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2150     return;
2151   } else {
2152     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2153     jchange = (int)change;
2154     swig_callbackOnStyleChange(jstyleManager, jchange);
2155   }
2156 }
2157
2158 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2159   bool c_result = SwigValueInit< bool >() ;
2160   unsigned int jresult = 0 ;
2161
2162   if (!swig_callbackOnAccessibilityActivated) {
2163     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2164   } else {
2165     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2166     c_result = jresult ? true : false;
2167   }
2168   return c_result;
2169 }
2170
2171 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2172   bool c_result = SwigValueInit< bool >() ;
2173   unsigned int jresult = 0 ;
2174   void * jgesture  ;
2175
2176   if (!swig_callbackOnAccessibilityPan) {
2177     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2178   } else {
2179     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2180     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2181     c_result = jresult ? true : false;
2182   }
2183   return c_result;
2184 }
2185
2186 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2187   bool c_result = SwigValueInit< bool >() ;
2188   unsigned int jresult = 0 ;
2189   void * jtouchEvent = 0 ;
2190
2191   if (!swig_callbackOnAccessibilityTouch) {
2192     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2193   } else {
2194     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2195     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2196     c_result = jresult ? true : false;
2197   }
2198   return c_result;
2199 }
2200
2201 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2202   bool c_result = SwigValueInit< bool >() ;
2203   unsigned int jresult = 0 ;
2204   unsigned int jisIncrease  ;
2205
2206   if (!swig_callbackOnAccessibilityValueChange) {
2207     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2208   } else {
2209     jisIncrease = isIncrease;
2210     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2211     c_result = jresult ? true : false;
2212   }
2213   return c_result;
2214 }
2215
2216 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2217   bool c_result = SwigValueInit< bool >() ;
2218   unsigned int jresult = 0 ;
2219
2220   if (!swig_callbackOnAccessibilityZoom) {
2221     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2222   } else {
2223     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2224     c_result = jresult ? true : false;
2225   }
2226   return c_result;
2227 }
2228
2229 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2230   if (!swig_callbackOnKeyInputFocusGained) {
2231     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2232     return;
2233   } else {
2234     swig_callbackOnKeyInputFocusGained();
2235   }
2236 }
2237
2238 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2239   if (!swig_callbackOnKeyInputFocusLost) {
2240     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2241     return;
2242   } else {
2243     swig_callbackOnKeyInputFocusLost();
2244   }
2245 }
2246
2247 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2248   Dali::Actor c_result ;
2249   void * jresult = 0 ;
2250   void * jcurrentFocusedActor  ;
2251   int jdirection  ;
2252   unsigned int jloopEnabled  ;
2253
2254   if (!swig_callbackGetNextKeyboardFocusableActor) {
2255     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2256   } else {
2257     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2258     jdirection = (int)direction;
2259     jloopEnabled = loopEnabled;
2260     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2261     if (!jresult) {
2262       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2263       return c_result;
2264     }
2265     c_result = *(Dali::Actor *)jresult;
2266   }
2267   return c_result;
2268 }
2269
2270 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2271   void * jcommitedFocusableActor  ;
2272
2273   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2274     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2275     return;
2276   } else {
2277     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2278     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2279   }
2280 }
2281
2282 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2283   bool c_result = SwigValueInit< bool >() ;
2284   unsigned int jresult = 0 ;
2285
2286   if (!swig_callbackOnKeyboardEnter) {
2287     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2288   } else {
2289     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2290     c_result = jresult ? true : false;
2291   }
2292   return c_result;
2293 }
2294
2295 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2296   void * jpinch = 0 ;
2297
2298   if (!swig_callbackOnPinch) {
2299     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2300     return;
2301   } else {
2302     jpinch = (Dali::PinchGesture *) &pinch;
2303     swig_callbackOnPinch(jpinch);
2304   }
2305 }
2306
2307 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2308   void * jpan = 0 ;
2309
2310   if (!swig_callbackOnPan) {
2311     Dali::Toolkit::Internal::Control::OnPan(pan);
2312     return;
2313   } else {
2314     jpan = (Dali::PanGesture *) &pan;
2315     swig_callbackOnPan(jpan);
2316   }
2317 }
2318
2319 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2320   void * jtap = 0 ;
2321
2322   if (!swig_callbackOnTap) {
2323     Dali::Toolkit::Internal::Control::OnTap(tap);
2324     return;
2325   } else {
2326     jtap = (Dali::TapGesture *) &tap;
2327     swig_callbackOnTap(jtap);
2328   }
2329 }
2330
2331 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2332   void * jlongPress = 0 ;
2333
2334   if (!swig_callbackOnLongPress) {
2335     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2336     return;
2337   } else {
2338     jlongPress = (Dali::LongPressGesture *) &longPress;
2339     swig_callbackOnLongPress(jlongPress);
2340   }
2341 }
2342
2343 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2344   void * jslotObserver = 0 ;
2345   void * jcallback = 0 ;
2346
2347   if (!swig_callbackSignalConnected) {
2348     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2349     return;
2350   } else {
2351     jslotObserver = (void *) slotObserver;
2352     jcallback = (void *) callback;
2353     swig_callbackSignalConnected(jslotObserver, jcallback);
2354   }
2355 }
2356
2357 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2358   void * jslotObserver = 0 ;
2359   void * jcallback = 0 ;
2360
2361   if (!swig_callbackSignalDisconnected) {
2362     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2363     return;
2364   } else {
2365     jslotObserver = (void *) slotObserver;
2366     jcallback = (void *) callback;
2367     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2368   }
2369 }
2370
2371 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2372   return Dali::Toolkit::Internal::Control::GetControlExtension();
2373 }
2374
2375 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) {
2376   swig_callbackOnStageConnection = callbackOnStageConnection;
2377   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2378   swig_callbackOnChildAdd = callbackOnChildAdd;
2379   swig_callbackOnChildRemove = callbackOnChildRemove;
2380   swig_callbackOnPropertySet = callbackOnPropertySet;
2381   swig_callbackOnSizeSet = callbackOnSizeSet;
2382   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2383   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2384   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2385   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2386   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2387   swig_callbackOnRelayout = callbackOnRelayout;
2388   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2389   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2390   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2391   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2392   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2393   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2394   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2395   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2396   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2397   swig_callbackOnInitialize = callbackOnInitialize;
2398   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2399   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2400   swig_callbackOnStyleChange = callbackOnStyleChange;
2401   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2402   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2403   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2404   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2405   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2406   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2407   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2408   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2409   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2410   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2411   swig_callbackOnPinch = callbackOnPinch;
2412   swig_callbackOnPan = callbackOnPan;
2413   swig_callbackOnTap = callbackOnTap;
2414   swig_callbackOnLongPress = callbackOnLongPress;
2415   swig_callbackSignalConnected = callbackSignalConnected;
2416   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2417 }
2418
2419 void SwigDirector_ViewImpl::swig_init_callbacks() {
2420   swig_callbackOnStageConnection = 0;
2421   swig_callbackOnStageDisconnection = 0;
2422   swig_callbackOnChildAdd = 0;
2423   swig_callbackOnChildRemove = 0;
2424   swig_callbackOnPropertySet = 0;
2425   swig_callbackOnSizeSet = 0;
2426   swig_callbackOnSizeAnimation = 0;
2427   swig_callbackOnTouchEvent = 0;
2428   swig_callbackOnHoverEvent = 0;
2429   swig_callbackOnKeyEvent = 0;
2430   swig_callbackOnWheelEvent = 0;
2431   swig_callbackOnRelayout = 0;
2432   swig_callbackOnSetResizePolicy = 0;
2433   swig_callbackGetNaturalSize = 0;
2434   swig_callbackCalculateChildSize = 0;
2435   swig_callbackGetHeightForWidth = 0;
2436   swig_callbackGetWidthForHeight = 0;
2437   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2438   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2439   swig_callbackOnCalculateRelayoutSize = 0;
2440   swig_callbackOnLayoutNegotiated = 0;
2441   swig_callbackOnInitialize = 0;
2442   swig_callbackOnControlChildAdd = 0;
2443   swig_callbackOnControlChildRemove = 0;
2444   swig_callbackOnStyleChange = 0;
2445   swig_callbackOnAccessibilityActivated = 0;
2446   swig_callbackOnAccessibilityPan = 0;
2447   swig_callbackOnAccessibilityTouch = 0;
2448   swig_callbackOnAccessibilityValueChange = 0;
2449   swig_callbackOnAccessibilityZoom = 0;
2450   swig_callbackOnKeyInputFocusGained = 0;
2451   swig_callbackOnKeyInputFocusLost = 0;
2452   swig_callbackGetNextKeyboardFocusableActor = 0;
2453   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2454   swig_callbackOnKeyboardEnter = 0;
2455   swig_callbackOnPinch = 0;
2456   swig_callbackOnPan = 0;
2457   swig_callbackOnTap = 0;
2458   swig_callbackOnLongPress = 0;
2459   swig_callbackSignalConnected = 0;
2460   swig_callbackSignalDisconnected = 0;
2461 }
2462
2463 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2464   swig_init_callbacks();
2465 }
2466
2467 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2468
2469 }
2470
2471
2472 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2473   unsigned int c_result = SwigValueInit< unsigned int >() ;
2474   unsigned int jresult = 0 ;
2475
2476   if (!swig_callbackGetNumberOfItems) {
2477     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2478   } else {
2479     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2480     c_result = (unsigned int)jresult;
2481   }
2482   return c_result;
2483 }
2484
2485 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2486   Dali::Actor c_result ;
2487   void * jresult = 0 ;
2488   unsigned int jitemId  ;
2489
2490   if (!swig_callbackNewItem) {
2491     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2492   } else {
2493     jitemId = itemId;
2494     jresult = (void *) swig_callbackNewItem(jitemId);
2495     if (!jresult) {
2496       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2497       return c_result;
2498     }
2499     c_result = *(Dali::Actor *)jresult;
2500   }
2501   return c_result;
2502 }
2503
2504 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2505   unsigned int jitemId  ;
2506   void * jactor  ;
2507
2508   if (!swig_callbackItemReleased) {
2509     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2510     return;
2511   } else {
2512     jitemId = itemId;
2513     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2514     swig_callbackItemReleased(jitemId, jactor);
2515   }
2516 }
2517
2518 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2519   return Dali::Toolkit::ItemFactory::GetExtension();
2520 }
2521
2522 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2523   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2524   swig_callbackNewItem = callbackNewItem;
2525   swig_callbackItemReleased = callbackItemReleased;
2526 }
2527
2528 void SwigDirector_ItemFactory::swig_init_callbacks() {
2529   swig_callbackGetNumberOfItems = 0;
2530   swig_callbackNewItem = 0;
2531   swig_callbackItemReleased = 0;
2532 }
2533
2534 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2535   swig_init_callbacks();
2536 }
2537
2538 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2539
2540 }
2541
2542
2543 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2544   Dali::Actor c_result ;
2545   void * jresult = 0 ;
2546   void * jcurrent  ;
2547   void * jproposed  ;
2548   int jdirection  ;
2549
2550   if (!swig_callbackGetNextFocusableActor) {
2551     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2552   } else {
2553     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2554     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2555     jdirection = (int)direction;
2556     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2557     if (!jresult) {
2558       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::Actor! Next focus will be NULL, please be cautious to handle the keyboard foucs! ", __FILE__, __LINE__);
2559       return c_result;
2560     }
2561     c_result = *(Dali::Actor *)jresult;
2562   }
2563   return c_result;
2564 }
2565
2566 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2567   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2568 }
2569
2570 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2571   swig_callbackGetNextFocusableActor = 0;
2572 }
2573
2574
2575 #ifdef __cplusplus
2576 extern "C" {
2577 #endif
2578
2579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2580   void * jresult ;
2581   floatp *result = 0 ;
2582
2583   {
2584     try {
2585       result = (floatp *)new_floatp();
2586     } catch (std::out_of_range& e) {
2587       {
2588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2589       };
2590     } catch (std::exception& e) {
2591       {
2592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2593       };
2594     } catch (DaliException e) {
2595       {
2596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2597       };
2598     } catch (...) {
2599       {
2600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2601       };
2602     }
2603   }
2604   jresult = (void *)result;
2605   return jresult;
2606 }
2607
2608
2609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2610   floatp *arg1 = (floatp *) 0 ;
2611
2612   arg1 = (floatp *)jarg1;
2613   {
2614     try {
2615       delete_floatp(arg1);
2616     } catch (std::out_of_range& e) {
2617       {
2618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2619       };
2620     } catch (std::exception& e) {
2621       {
2622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2623       };
2624     } catch (Dali::DaliException e) {
2625       {
2626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2627       };
2628     } catch (...) {
2629       {
2630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2631       };
2632     }
2633   }
2634
2635 }
2636
2637
2638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2639   floatp *arg1 = (floatp *) 0 ;
2640   float arg2 ;
2641
2642   arg1 = (floatp *)jarg1;
2643   arg2 = (float)jarg2;
2644   {
2645     try {
2646       floatp_assign(arg1,arg2);
2647     } catch (std::out_of_range& e) {
2648       {
2649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2650       };
2651     } catch (std::exception& e) {
2652       {
2653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2654       };
2655     } catch (Dali::DaliException e) {
2656       {
2657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2658       };
2659     } catch (...) {
2660       {
2661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2662       };
2663     }
2664   }
2665
2666 }
2667
2668
2669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2670   float jresult ;
2671   floatp *arg1 = (floatp *) 0 ;
2672   float result;
2673
2674   arg1 = (floatp *)jarg1;
2675   {
2676     try {
2677       result = (float)floatp_value(arg1);
2678     } catch (std::out_of_range& e) {
2679       {
2680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2681       };
2682     } catch (std::exception& e) {
2683       {
2684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2685       };
2686     } catch (DaliException e) {
2687       {
2688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2689       };
2690     } catch (...) {
2691       {
2692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2693       };
2694     }
2695   }
2696   jresult = result;
2697   return jresult;
2698 }
2699
2700
2701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2702   void * jresult ;
2703   floatp *arg1 = (floatp *) 0 ;
2704   float *result = 0 ;
2705
2706   arg1 = (floatp *)jarg1;
2707   {
2708     try {
2709       result = (float *)floatp_cast(arg1);
2710     } catch (std::out_of_range& e) {
2711       {
2712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2713       };
2714     } catch (std::exception& e) {
2715       {
2716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2717       };
2718     } catch (Dali::DaliException e) {
2719       {
2720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2721       };
2722     } catch (...) {
2723       {
2724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2725       };
2726     }
2727   }
2728
2729   jresult = (void *)result;
2730   return jresult;
2731 }
2732
2733
2734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2735   void * jresult ;
2736   float *arg1 = (float *) 0 ;
2737   floatp *result = 0 ;
2738
2739   arg1 = (float *)jarg1;
2740   {
2741     try {
2742       result = (floatp *)floatp_frompointer(arg1);
2743     } catch (std::out_of_range& e) {
2744       {
2745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2746       };
2747     } catch (std::exception& e) {
2748       {
2749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2750       };
2751     } catch (Dali::DaliException e) {
2752       {
2753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2754       };
2755     } catch (...) {
2756       {
2757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2758       };
2759     }
2760   }
2761
2762   jresult = (void *)result;
2763   return jresult;
2764 }
2765
2766
2767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2768   void * jresult ;
2769   intp *result = 0 ;
2770
2771   {
2772     try {
2773       result = (intp *)new_intp();
2774     } catch (std::out_of_range& e) {
2775       {
2776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2777       };
2778     } catch (std::exception& e) {
2779       {
2780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2781       };
2782     } catch (Dali::DaliException e) {
2783       {
2784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2785       };
2786     } catch (...) {
2787       {
2788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2789       };
2790     }
2791   }
2792
2793   jresult = (void *)result;
2794   return jresult;
2795 }
2796
2797
2798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2799   intp *arg1 = (intp *) 0 ;
2800
2801   arg1 = (intp *)jarg1;
2802   {
2803     try {
2804       delete_intp(arg1);
2805     } catch (std::out_of_range& e) {
2806       {
2807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2808       };
2809     } catch (std::exception& e) {
2810       {
2811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2812       };
2813     } catch (Dali::DaliException e) {
2814       {
2815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2816       };
2817     } catch (...) {
2818       {
2819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2820       };
2821     }
2822   }
2823
2824 }
2825
2826
2827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2828   intp *arg1 = (intp *) 0 ;
2829   int arg2 ;
2830
2831   arg1 = (intp *)jarg1;
2832   arg2 = (int)jarg2;
2833   {
2834     try {
2835       intp_assign(arg1,arg2);
2836     } catch (std::out_of_range& e) {
2837       {
2838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2839       };
2840     } catch (std::exception& e) {
2841       {
2842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2843       };
2844     } catch (Dali::DaliException e) {
2845       {
2846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2847       };
2848     } catch (...) {
2849       {
2850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2851       };
2852     }
2853   }
2854
2855 }
2856
2857
2858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2859   int jresult ;
2860   intp *arg1 = (intp *) 0 ;
2861   int result;
2862
2863   arg1 = (intp *)jarg1;
2864   {
2865     try {
2866       result = (int)intp_value(arg1);
2867     } catch (std::out_of_range& e) {
2868       {
2869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2870       };
2871     } catch (std::exception& e) {
2872       {
2873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2874       };
2875     } catch (Dali::DaliException e) {
2876       {
2877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2878       };
2879     } catch (...) {
2880       {
2881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2882       };
2883     }
2884   }
2885
2886   jresult = result;
2887   return jresult;
2888 }
2889
2890
2891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2892   void * jresult ;
2893   intp *arg1 = (intp *) 0 ;
2894   int *result = 0 ;
2895
2896   arg1 = (intp *)jarg1;
2897   {
2898     try {
2899       result = (int *)intp_cast(arg1);
2900     } catch (std::out_of_range& e) {
2901       {
2902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2903       };
2904     } catch (std::exception& e) {
2905       {
2906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2907       };
2908     } catch (Dali::DaliException e) {
2909       {
2910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2911       };
2912     } catch (...) {
2913       {
2914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2915       };
2916     }
2917   }
2918
2919   jresult = (void *)result;
2920   return jresult;
2921 }
2922
2923
2924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2925   void * jresult ;
2926   int *arg1 = (int *) 0 ;
2927   intp *result = 0 ;
2928
2929   arg1 = (int *)jarg1;
2930   {
2931     try {
2932       result = (intp *)intp_frompointer(arg1);
2933     } catch (std::out_of_range& e) {
2934       {
2935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2936       };
2937     } catch (std::exception& e) {
2938       {
2939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2940       };
2941     } catch (Dali::DaliException e) {
2942       {
2943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2944       };
2945     } catch (...) {
2946       {
2947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2948       };
2949     }
2950   }
2951
2952   jresult = (void *)result;
2953   return jresult;
2954 }
2955
2956
2957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2958   void * jresult ;
2959   doublep *result = 0 ;
2960
2961   {
2962     try {
2963       result = (doublep *)new_doublep();
2964     } catch (std::out_of_range& e) {
2965       {
2966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2967       };
2968     } catch (std::exception& e) {
2969       {
2970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2971       };
2972     } catch (Dali::DaliException e) {
2973       {
2974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2975       };
2976     } catch (...) {
2977       {
2978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2979       };
2980     }
2981   }
2982
2983   jresult = (void *)result;
2984   return jresult;
2985 }
2986
2987
2988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2989   doublep *arg1 = (doublep *) 0 ;
2990
2991   arg1 = (doublep *)jarg1;
2992   {
2993     try {
2994       delete_doublep(arg1);
2995     } catch (std::out_of_range& e) {
2996       {
2997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2998       };
2999     } catch (std::exception& e) {
3000       {
3001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3002       };
3003     } catch (Dali::DaliException e) {
3004       {
3005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3006       };
3007     } catch (...) {
3008       {
3009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3010       };
3011     }
3012   }
3013
3014 }
3015
3016
3017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3018   doublep *arg1 = (doublep *) 0 ;
3019   double arg2 ;
3020
3021   arg1 = (doublep *)jarg1;
3022   arg2 = (double)jarg2;
3023   {
3024     try {
3025       doublep_assign(arg1,arg2);
3026     } catch (std::out_of_range& e) {
3027       {
3028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3029       };
3030     } catch (std::exception& e) {
3031       {
3032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3033       };
3034     } catch (Dali::DaliException e) {
3035       {
3036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3037       };
3038     } catch (...) {
3039       {
3040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3041       };
3042     }
3043   }
3044
3045 }
3046
3047
3048 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3049   double jresult ;
3050   doublep *arg1 = (doublep *) 0 ;
3051   double result;
3052
3053   arg1 = (doublep *)jarg1;
3054   {
3055     try {
3056       result = (double)doublep_value(arg1);
3057     } catch (std::out_of_range& e) {
3058       {
3059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3060       };
3061     } catch (std::exception& e) {
3062       {
3063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3064       };
3065     } catch (Dali::DaliException e) {
3066       {
3067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3068       };
3069     } catch (...) {
3070       {
3071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3072       };
3073     }
3074   }
3075
3076   jresult = result;
3077   return jresult;
3078 }
3079
3080
3081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3082   void * jresult ;
3083   doublep *arg1 = (doublep *) 0 ;
3084   double *result = 0 ;
3085
3086   arg1 = (doublep *)jarg1;
3087   {
3088     try {
3089       result = (double *)doublep_cast(arg1);
3090     } catch (std::out_of_range& e) {
3091       {
3092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3093       };
3094     } catch (std::exception& e) {
3095       {
3096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3097       };
3098     } catch (Dali::DaliException e) {
3099       {
3100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3101       };
3102     } catch (...) {
3103       {
3104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3105       };
3106     }
3107   }
3108
3109   jresult = (void *)result;
3110   return jresult;
3111 }
3112
3113
3114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3115   void * jresult ;
3116   double *arg1 = (double *) 0 ;
3117   doublep *result = 0 ;
3118
3119   arg1 = (double *)jarg1;
3120   {
3121     try {
3122       result = (doublep *)doublep_frompointer(arg1);
3123     } catch (std::out_of_range& e) {
3124       {
3125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3126       };
3127     } catch (std::exception& e) {
3128       {
3129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3130       };
3131     } catch (Dali::DaliException e) {
3132       {
3133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3134       };
3135     } catch (...) {
3136       {
3137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3138       };
3139     }
3140   }
3141
3142   jresult = (void *)result;
3143   return jresult;
3144 }
3145
3146
3147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3148   void * jresult ;
3149   uintp *result = 0 ;
3150
3151   {
3152     try {
3153       result = (uintp *)new_uintp();
3154     } catch (std::out_of_range& e) {
3155       {
3156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3157       };
3158     } catch (std::exception& e) {
3159       {
3160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3161       };
3162     } catch (Dali::DaliException e) {
3163       {
3164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3165       };
3166     } catch (...) {
3167       {
3168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3169       };
3170     }
3171   }
3172
3173   jresult = (void *)result;
3174   return jresult;
3175 }
3176
3177
3178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3179   uintp *arg1 = (uintp *) 0 ;
3180
3181   arg1 = (uintp *)jarg1;
3182   {
3183     try {
3184       delete_uintp(arg1);
3185     } catch (std::out_of_range& e) {
3186       {
3187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3188       };
3189     } catch (std::exception& e) {
3190       {
3191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3192       };
3193     } catch (Dali::DaliException e) {
3194       {
3195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3196       };
3197     } catch (...) {
3198       {
3199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3200       };
3201     }
3202   }
3203
3204 }
3205
3206
3207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3208   uintp *arg1 = (uintp *) 0 ;
3209   unsigned int arg2 ;
3210
3211   arg1 = (uintp *)jarg1;
3212   arg2 = (unsigned int)jarg2;
3213   {
3214     try {
3215       uintp_assign(arg1,arg2);
3216     } catch (std::out_of_range& e) {
3217       {
3218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3219       };
3220     } catch (std::exception& e) {
3221       {
3222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3223       };
3224     } catch (Dali::DaliException e) {
3225       {
3226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3227       };
3228     } catch (...) {
3229       {
3230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3231       };
3232     }
3233   }
3234
3235 }
3236
3237
3238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3239   unsigned int jresult ;
3240   uintp *arg1 = (uintp *) 0 ;
3241   unsigned int result;
3242
3243   arg1 = (uintp *)jarg1;
3244   {
3245     try {
3246       result = (unsigned int)uintp_value(arg1);
3247     } catch (std::out_of_range& e) {
3248       {
3249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3250       };
3251     } catch (std::exception& e) {
3252       {
3253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3254       };
3255     } catch (Dali::DaliException e) {
3256       {
3257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3258       };
3259     } catch (...) {
3260       {
3261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3262       };
3263     }
3264   }
3265
3266   jresult = result;
3267   return jresult;
3268 }
3269
3270
3271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3272   void * jresult ;
3273   uintp *arg1 = (uintp *) 0 ;
3274   unsigned int *result = 0 ;
3275
3276   arg1 = (uintp *)jarg1;
3277   {
3278     try {
3279       result = (unsigned int *)uintp_cast(arg1);
3280     } catch (std::out_of_range& e) {
3281       {
3282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3283       };
3284     } catch (std::exception& e) {
3285       {
3286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3287       };
3288     } catch (Dali::DaliException e) {
3289       {
3290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3291       };
3292     } catch (...) {
3293       {
3294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3295       };
3296     }
3297   }
3298
3299   jresult = (void *)result;
3300   return jresult;
3301 }
3302
3303
3304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3305   void * jresult ;
3306   unsigned int *arg1 = (unsigned int *) 0 ;
3307   uintp *result = 0 ;
3308
3309   arg1 = (unsigned int *)jarg1;
3310   {
3311     try {
3312       result = (uintp *)uintp_frompointer(arg1);
3313     } catch (std::out_of_range& e) {
3314       {
3315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3316       };
3317     } catch (std::exception& e) {
3318       {
3319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3320       };
3321     } catch (Dali::DaliException e) {
3322       {
3323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3324       };
3325     } catch (...) {
3326       {
3327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3328       };
3329     }
3330   }
3331
3332   jresult = (void *)result;
3333   return jresult;
3334 }
3335
3336
3337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3338   void * jresult ;
3339   ushortp *result = 0 ;
3340
3341   {
3342     try {
3343       result = (ushortp *)new_ushortp();
3344     } catch (std::out_of_range& e) {
3345       {
3346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3347       };
3348     } catch (std::exception& e) {
3349       {
3350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3351       };
3352     } catch (Dali::DaliException e) {
3353       {
3354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3355       };
3356     } catch (...) {
3357       {
3358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3359       };
3360     }
3361   }
3362
3363   jresult = (void *)result;
3364   return jresult;
3365 }
3366
3367
3368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3369   ushortp *arg1 = (ushortp *) 0 ;
3370
3371   arg1 = (ushortp *)jarg1;
3372   {
3373     try {
3374       delete_ushortp(arg1);
3375     } catch (std::out_of_range& e) {
3376       {
3377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3378       };
3379     } catch (std::exception& e) {
3380       {
3381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3382       };
3383     } catch (Dali::DaliException e) {
3384       {
3385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3386       };
3387     } catch (...) {
3388       {
3389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3390       };
3391     }
3392   }
3393
3394 }
3395
3396
3397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3398   ushortp *arg1 = (ushortp *) 0 ;
3399   unsigned short arg2 ;
3400
3401   arg1 = (ushortp *)jarg1;
3402   arg2 = (unsigned short)jarg2;
3403   {
3404     try {
3405       ushortp_assign(arg1,arg2);
3406     } catch (std::out_of_range& e) {
3407       {
3408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3409       };
3410     } catch (std::exception& e) {
3411       {
3412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3413       };
3414     } catch (Dali::DaliException e) {
3415       {
3416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3417       };
3418     } catch (...) {
3419       {
3420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3421       };
3422     }
3423   }
3424
3425 }
3426
3427
3428 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3429   unsigned short jresult ;
3430   ushortp *arg1 = (ushortp *) 0 ;
3431   unsigned short result;
3432
3433   arg1 = (ushortp *)jarg1;
3434   {
3435     try {
3436       result = (unsigned short)ushortp_value(arg1);
3437     } catch (std::out_of_range& e) {
3438       {
3439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3440       };
3441     } catch (std::exception& e) {
3442       {
3443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3444       };
3445     } catch (Dali::DaliException e) {
3446       {
3447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3448       };
3449     } catch (...) {
3450       {
3451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3452       };
3453     }
3454   }
3455
3456   jresult = result;
3457   return jresult;
3458 }
3459
3460
3461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3462   void * jresult ;
3463   ushortp *arg1 = (ushortp *) 0 ;
3464   unsigned short *result = 0 ;
3465
3466   arg1 = (ushortp *)jarg1;
3467   {
3468     try {
3469       result = (unsigned short *)ushortp_cast(arg1);
3470     } catch (std::out_of_range& e) {
3471       {
3472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3473       };
3474     } catch (std::exception& e) {
3475       {
3476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3477       };
3478     } catch (Dali::DaliException e) {
3479       {
3480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3481       };
3482     } catch (...) {
3483       {
3484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3485       };
3486     }
3487   }
3488
3489   jresult = (void *)result;
3490   return jresult;
3491 }
3492
3493
3494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3495   void * jresult ;
3496   unsigned short *arg1 = (unsigned short *) 0 ;
3497   ushortp *result = 0 ;
3498
3499   arg1 = (unsigned short *)jarg1;
3500   {
3501     try {
3502       result = (ushortp *)ushortp_frompointer(arg1);
3503     } catch (std::out_of_range& e) {
3504       {
3505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3506       };
3507     } catch (std::exception& e) {
3508       {
3509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3510       };
3511     } catch (Dali::DaliException e) {
3512       {
3513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3514       };
3515     } catch (...) {
3516       {
3517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3518       };
3519     }
3520   }
3521
3522   jresult = (void *)result;
3523   return jresult;
3524 }
3525
3526
3527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3528   unsigned int jresult ;
3529   int arg1 ;
3530   unsigned int result;
3531
3532   arg1 = (int)jarg1;
3533   {
3534     try {
3535       result = (unsigned int)int_to_uint(arg1);
3536     } catch (std::out_of_range& e) {
3537       {
3538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3539       };
3540     } catch (std::exception& e) {
3541       {
3542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3543       };
3544     } catch (Dali::DaliException e) {
3545       {
3546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3547       };
3548     } catch (...) {
3549       {
3550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3551       };
3552     }
3553   }
3554
3555   jresult = result;
3556   return jresult;
3557 }
3558
3559
3560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3561   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3562
3563   arg1 = (Dali::RefObject *)jarg1;
3564   {
3565     try {
3566       (arg1)->Reference();
3567     } catch (std::out_of_range& e) {
3568       {
3569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3570       };
3571     } catch (std::exception& e) {
3572       {
3573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3574       };
3575     } catch (Dali::DaliException e) {
3576       {
3577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3578       };
3579     } catch (...) {
3580       {
3581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3582       };
3583     }
3584   }
3585
3586 }
3587
3588
3589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3590   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3591
3592   arg1 = (Dali::RefObject *)jarg1;
3593   {
3594     try {
3595       (arg1)->Unreference();
3596     } catch (std::out_of_range& e) {
3597       {
3598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3599       };
3600     } catch (std::exception& e) {
3601       {
3602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3603       };
3604     } catch (Dali::DaliException e) {
3605       {
3606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3607       };
3608     } catch (...) {
3609       {
3610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3611       };
3612     }
3613   }
3614
3615 }
3616
3617
3618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3619   int jresult ;
3620   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3621   int result;
3622
3623   arg1 = (Dali::RefObject *)jarg1;
3624   {
3625     try {
3626       result = (int)(arg1)->ReferenceCount();
3627     } catch (std::out_of_range& e) {
3628       {
3629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3630       };
3631     } catch (std::exception& e) {
3632       {
3633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3634       };
3635     } catch (Dali::DaliException e) {
3636       {
3637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3638       };
3639     } catch (...) {
3640       {
3641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3642       };
3643     }
3644   }
3645
3646   jresult = result;
3647   return jresult;
3648 }
3649
3650
3651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3652   void * jresult ;
3653   Dali::Any *result = 0 ;
3654
3655   {
3656     try {
3657       result = (Dali::Any *)new Dali::Any();
3658     } catch (std::out_of_range& e) {
3659       {
3660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3661       };
3662     } catch (std::exception& e) {
3663       {
3664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3665       };
3666     } catch (Dali::DaliException e) {
3667       {
3668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3669       };
3670     } catch (...) {
3671       {
3672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3673       };
3674     }
3675   }
3676
3677   jresult = (void *)result;
3678   return jresult;
3679 }
3680
3681
3682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3683   Dali::Any *arg1 = (Dali::Any *) 0 ;
3684
3685   arg1 = (Dali::Any *)jarg1;
3686   {
3687     try {
3688       delete arg1;
3689     } catch (std::out_of_range& e) {
3690       {
3691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3692       };
3693     } catch (std::exception& e) {
3694       {
3695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3696       };
3697     } catch (Dali::DaliException e) {
3698       {
3699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3700       };
3701     } catch (...) {
3702       {
3703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3704       };
3705     }
3706   }
3707
3708 }
3709
3710
3711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3712   char *arg1 = (char *) 0 ;
3713
3714   arg1 = (char *)jarg1;
3715   {
3716     try {
3717       Dali::Any::AssertAlways((char const *)arg1);
3718     } catch (std::out_of_range& e) {
3719       {
3720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3721       };
3722     } catch (std::exception& e) {
3723       {
3724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3725       };
3726     } catch (Dali::DaliException e) {
3727       {
3728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3729       };
3730     } catch (...) {
3731       {
3732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3733       };
3734     }
3735   }
3736
3737 }
3738
3739
3740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3741   void * jresult ;
3742   Dali::Any *arg1 = 0 ;
3743   Dali::Any *result = 0 ;
3744
3745   arg1 = (Dali::Any *)jarg1;
3746   if (!arg1) {
3747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3748     return 0;
3749   }
3750   {
3751     try {
3752       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3753     } catch (std::out_of_range& e) {
3754       {
3755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3756       };
3757     } catch (std::exception& e) {
3758       {
3759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3760       };
3761     } catch (Dali::DaliException e) {
3762       {
3763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3764       };
3765     } catch (...) {
3766       {
3767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3768       };
3769     }
3770   }
3771
3772   jresult = (void *)result;
3773   return jresult;
3774 }
3775
3776
3777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3778   void * jresult ;
3779   Dali::Any *arg1 = (Dali::Any *) 0 ;
3780   Dali::Any *arg2 = 0 ;
3781   Dali::Any *result = 0 ;
3782
3783   arg1 = (Dali::Any *)jarg1;
3784   arg2 = (Dali::Any *)jarg2;
3785   if (!arg2) {
3786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3787     return 0;
3788   }
3789   {
3790     try {
3791       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3792     } catch (std::out_of_range& e) {
3793       {
3794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3795       };
3796     } catch (std::exception& e) {
3797       {
3798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3799       };
3800     } catch (Dali::DaliException e) {
3801       {
3802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3803       };
3804     } catch (...) {
3805       {
3806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3807       };
3808     }
3809   }
3810
3811   jresult = (void *)result;
3812   return jresult;
3813 }
3814
3815
3816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3817   void * jresult ;
3818   Dali::Any *arg1 = (Dali::Any *) 0 ;
3819   std::type_info *result = 0 ;
3820
3821   arg1 = (Dali::Any *)jarg1;
3822   {
3823     try {
3824       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3825     } catch (std::out_of_range& e) {
3826       {
3827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3828       };
3829     } catch (std::exception& e) {
3830       {
3831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3832       };
3833     } catch (Dali::DaliException e) {
3834       {
3835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3836       };
3837     } catch (...) {
3838       {
3839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3840       };
3841     }
3842   }
3843
3844   jresult = (void *)result;
3845   return jresult;
3846 }
3847
3848
3849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3850   unsigned int jresult ;
3851   Dali::Any *arg1 = (Dali::Any *) 0 ;
3852   bool result;
3853
3854   arg1 = (Dali::Any *)jarg1;
3855   {
3856     try {
3857       result = (bool)((Dali::Any const *)arg1)->Empty();
3858     } catch (std::out_of_range& e) {
3859       {
3860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3861       };
3862     } catch (std::exception& e) {
3863       {
3864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3865       };
3866     } catch (Dali::DaliException e) {
3867       {
3868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3869       };
3870     } catch (...) {
3871       {
3872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3873       };
3874     }
3875   }
3876
3877   jresult = result;
3878   return jresult;
3879 }
3880
3881
3882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3883   void * jresult ;
3884   std::type_info *arg1 = 0 ;
3885   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3886   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3887   Dali::Any::AnyContainerBase *result = 0 ;
3888
3889   arg1 = (std::type_info *)jarg1;
3890   if (!arg1) {
3891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3892     return 0;
3893   }
3894   arg2 = (Dali::Any::CloneFunc)jarg2;
3895   arg3 = (Dali::Any::DeleteFunc)jarg3;
3896   {
3897     try {
3898       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3899     } catch (std::out_of_range& e) {
3900       {
3901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3902       };
3903     } catch (std::exception& e) {
3904       {
3905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3906       };
3907     } catch (Dali::DaliException e) {
3908       {
3909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3910       };
3911     } catch (...) {
3912       {
3913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3914       };
3915     }
3916   }
3917
3918   jresult = (void *)result;
3919   return jresult;
3920 }
3921
3922
3923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3924   void * jresult ;
3925   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3926   std::type_info *result = 0 ;
3927
3928   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3929   {
3930     try {
3931       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3932     } catch (std::out_of_range& e) {
3933       {
3934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3935       };
3936     } catch (std::exception& e) {
3937       {
3938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3939       };
3940     } catch (Dali::DaliException e) {
3941       {
3942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3943       };
3944     } catch (...) {
3945       {
3946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3947       };
3948     }
3949   }
3950
3951   jresult = (void *)result;
3952   return jresult;
3953 }
3954
3955
3956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3957   void * jresult ;
3958   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3959   ::std::type_info *result = 0 ;
3960
3961   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3962   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3963   jresult = (void *)result;
3964   return jresult;
3965 }
3966
3967
3968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3969   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3970   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3971
3972   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3973   arg2 = (Dali::Any::CloneFunc)jarg2;
3974   if (arg1) (arg1)->mCloneFunc = arg2;
3975 }
3976
3977
3978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3979   void * jresult ;
3980   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3981   Dali::Any::CloneFunc result;
3982
3983   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3984   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3985   jresult = (void *)result;
3986   return jresult;
3987 }
3988
3989
3990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3991   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3992   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3993
3994   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3995   arg2 = (Dali::Any::DeleteFunc)jarg2;
3996   if (arg1) (arg1)->mDeleteFunc = arg2;
3997 }
3998
3999
4000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4001   void * jresult ;
4002   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4003   Dali::Any::DeleteFunc result;
4004
4005   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4006   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4007   jresult = (void *)result;
4008   return jresult;
4009 }
4010
4011
4012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4013   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4014
4015   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4016   {
4017     try {
4018       delete arg1;
4019     } catch (std::out_of_range& e) {
4020       {
4021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4022       };
4023     } catch (std::exception& e) {
4024       {
4025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4026       };
4027     } catch (Dali::DaliException e) {
4028       {
4029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4030       };
4031     } catch (...) {
4032       {
4033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4034       };
4035     }
4036   }
4037
4038 }
4039
4040
4041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4042   Dali::Any *arg1 = (Dali::Any *) 0 ;
4043   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4044
4045   arg1 = (Dali::Any *)jarg1;
4046   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4047   if (arg1) (arg1)->mContainer = arg2;
4048 }
4049
4050
4051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4052   void * jresult ;
4053   Dali::Any *arg1 = (Dali::Any *) 0 ;
4054   Dali::Any::AnyContainerBase *result = 0 ;
4055
4056   arg1 = (Dali::Any *)jarg1;
4057   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4058   jresult = (void *)result;
4059   return jresult;
4060 }
4061
4062
4063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4064   char *arg1 = (char *) 0 ;
4065   char *arg2 = (char *) 0 ;
4066
4067   arg1 = (char *)jarg1;
4068   arg2 = (char *)jarg2;
4069   {
4070     try {
4071       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4072     } catch (std::out_of_range& e) {
4073       {
4074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4075       };
4076     } catch (std::exception& e) {
4077       {
4078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4079       };
4080     } catch (Dali::DaliException e) {
4081       {
4082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4083       };
4084     } catch (...) {
4085       {
4086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4087       };
4088     }
4089   }
4090
4091 }
4092
4093
4094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4095   void * jresult ;
4096   char *arg1 = (char *) 0 ;
4097   char *arg2 = (char *) 0 ;
4098   Dali::DaliException *result = 0 ;
4099
4100   arg1 = (char *)jarg1;
4101   arg2 = (char *)jarg2;
4102   {
4103     try {
4104       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4105     } catch (std::out_of_range& e) {
4106       {
4107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4108       };
4109     } catch (std::exception& e) {
4110       {
4111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4112       };
4113     } catch (Dali::DaliException e) {
4114       {
4115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4116       };
4117     } catch (...) {
4118       {
4119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4120       };
4121     }
4122   }
4123
4124   jresult = (void *)result;
4125   return jresult;
4126 }
4127
4128
4129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4130   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4131   std::string arg2 = std::string(jarg2);
4132
4133   arg1 = (Dali::DaliException *)jarg1;
4134   {
4135     if (!arg2.empty()) {
4136       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4137     } else {
4138       arg1->location = 0;
4139     }
4140   }
4141 }
4142
4143 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4144   char * jresult ;
4145   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4146   char *result = 0 ;
4147
4148   arg1 = (Dali::DaliException *)jarg1;
4149   result = (char *) ((arg1)->location);
4150   jresult = SWIG_csharp_string_callback((const char *)result);
4151   return jresult;
4152 }
4153
4154
4155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4156   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4157   std::string arg2 = std::string(jarg2);
4158
4159   arg1 = (Dali::DaliException *)jarg1;
4160   {
4161     if (!arg2.empty()) {
4162       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4163     } else {
4164       arg1->condition = 0;
4165     }
4166   }
4167 }
4168
4169
4170 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4171   char * jresult ;
4172   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4173   char *result = 0 ;
4174
4175   arg1 = (Dali::DaliException *)jarg1;
4176   result = (char *) ((arg1)->condition);
4177   jresult = SWIG_csharp_string_callback((const char *)result);
4178   return jresult;
4179 }
4180
4181
4182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4183   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4184
4185   arg1 = (Dali::DaliException *)jarg1;
4186   {
4187     try {
4188       delete arg1;
4189     } catch (std::out_of_range& e) {
4190       {
4191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4192       };
4193     } catch (std::exception& e) {
4194       {
4195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4196       };
4197     } catch (Dali::DaliException e) {
4198       {
4199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4200       };
4201     } catch (...) {
4202       {
4203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4204       };
4205     }
4206   }
4207
4208 }
4209
4210
4211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4212   void * jresult ;
4213   Dali::Vector2 *result = 0 ;
4214
4215   {
4216     try {
4217       result = (Dali::Vector2 *)new Dali::Vector2();
4218     } catch (std::out_of_range& e) {
4219       {
4220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4221       };
4222     } catch (std::exception& e) {
4223       {
4224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4225       };
4226     } catch (Dali::DaliException e) {
4227       {
4228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4229       };
4230     } catch (...) {
4231       {
4232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4233       };
4234     }
4235   }
4236
4237   jresult = (void *)result;
4238   return jresult;
4239 }
4240
4241
4242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4243   void * jresult ;
4244   float arg1 ;
4245   float arg2 ;
4246   Dali::Vector2 *result = 0 ;
4247
4248   arg1 = (float)jarg1;
4249   arg2 = (float)jarg2;
4250   {
4251     try {
4252       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4253     } catch (std::out_of_range& e) {
4254       {
4255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4256       };
4257     } catch (std::exception& e) {
4258       {
4259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4260       };
4261     } catch (Dali::DaliException e) {
4262       {
4263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4264       };
4265     } catch (...) {
4266       {
4267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4268       };
4269     }
4270   }
4271
4272   jresult = (void *)result;
4273   return jresult;
4274 }
4275
4276
4277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4278   void * jresult ;
4279   float *arg1 = (float *) 0 ;
4280   Dali::Vector2 *result = 0 ;
4281
4282   arg1 = jarg1;
4283   {
4284     try {
4285       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4286     } catch (std::out_of_range& e) {
4287       {
4288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4289       };
4290     } catch (std::exception& e) {
4291       {
4292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4293       };
4294     } catch (Dali::DaliException e) {
4295       {
4296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4297       };
4298     } catch (...) {
4299       {
4300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4301       };
4302     }
4303   }
4304
4305   jresult = (void *)result;
4306
4307
4308   return jresult;
4309 }
4310
4311
4312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4313   void * jresult ;
4314   Dali::Vector3 *arg1 = 0 ;
4315   Dali::Vector2 *result = 0 ;
4316
4317   arg1 = (Dali::Vector3 *)jarg1;
4318   if (!arg1) {
4319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4320     return 0;
4321   }
4322   {
4323     try {
4324       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4325     } catch (std::out_of_range& e) {
4326       {
4327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4328       };
4329     } catch (std::exception& e) {
4330       {
4331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4332       };
4333     } catch (Dali::DaliException e) {
4334       {
4335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4336       };
4337     } catch (...) {
4338       {
4339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4340       };
4341     }
4342   }
4343
4344   jresult = (void *)result;
4345   return jresult;
4346 }
4347
4348
4349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4350   void * jresult ;
4351   Dali::Vector4 *arg1 = 0 ;
4352   Dali::Vector2 *result = 0 ;
4353
4354   arg1 = (Dali::Vector4 *)jarg1;
4355   if (!arg1) {
4356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4357     return 0;
4358   }
4359   {
4360     try {
4361       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4362     } catch (std::out_of_range& e) {
4363       {
4364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4365       };
4366     } catch (std::exception& e) {
4367       {
4368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4369       };
4370     } catch (Dali::DaliException e) {
4371       {
4372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4373       };
4374     } catch (...) {
4375       {
4376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4377       };
4378     }
4379   }
4380
4381   jresult = (void *)result;
4382   return jresult;
4383 }
4384
4385
4386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4387   void * jresult ;
4388   Dali::Vector2 *result = 0 ;
4389
4390   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4391   jresult = (void *)result;
4392   return jresult;
4393 }
4394
4395
4396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4397   void * jresult ;
4398   Dali::Vector2 *result = 0 ;
4399
4400   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4401   jresult = (void *)result;
4402   return jresult;
4403 }
4404
4405
4406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4407   void * jresult ;
4408   Dali::Vector2 *result = 0 ;
4409
4410   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4411   jresult = (void *)result;
4412   return jresult;
4413 }
4414
4415
4416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4417   void * jresult ;
4418   Dali::Vector2 *result = 0 ;
4419
4420   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4421   jresult = (void *)result;
4422   return jresult;
4423 }
4424
4425
4426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4427   void * jresult ;
4428   Dali::Vector2 *result = 0 ;
4429
4430   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4431   jresult = (void *)result;
4432   return jresult;
4433 }
4434
4435
4436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4437   void * jresult ;
4438   Dali::Vector2 *result = 0 ;
4439
4440   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4441   jresult = (void *)result;
4442   return jresult;
4443 }
4444
4445
4446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4447   void * jresult ;
4448   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4449   float *arg2 = (float *) 0 ;
4450   Dali::Vector2 *result = 0 ;
4451
4452   arg1 = (Dali::Vector2 *)jarg1;
4453   arg2 = jarg2;
4454   {
4455     try {
4456       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4457     } catch (std::out_of_range& e) {
4458       {
4459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4460       };
4461     } catch (std::exception& e) {
4462       {
4463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4464       };
4465     } catch (Dali::DaliException e) {
4466       {
4467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4468       };
4469     } catch (...) {
4470       {
4471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4472       };
4473     }
4474   }
4475
4476   jresult = (void *)result;
4477
4478
4479   return jresult;
4480 }
4481
4482
4483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4484   void * jresult ;
4485   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4486   Dali::Vector3 *arg2 = 0 ;
4487   Dali::Vector2 *result = 0 ;
4488
4489   arg1 = (Dali::Vector2 *)jarg1;
4490   arg2 = (Dali::Vector3 *)jarg2;
4491   if (!arg2) {
4492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4493     return 0;
4494   }
4495   {
4496     try {
4497       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4498     } catch (std::out_of_range& e) {
4499       {
4500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4501       };
4502     } catch (std::exception& e) {
4503       {
4504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4505       };
4506     } catch (Dali::DaliException e) {
4507       {
4508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4509       };
4510     } catch (...) {
4511       {
4512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4513       };
4514     }
4515   }
4516
4517   jresult = (void *)result;
4518   return jresult;
4519 }
4520
4521
4522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4523   void * jresult ;
4524   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4525   Dali::Vector4 *arg2 = 0 ;
4526   Dali::Vector2 *result = 0 ;
4527
4528   arg1 = (Dali::Vector2 *)jarg1;
4529   arg2 = (Dali::Vector4 *)jarg2;
4530   if (!arg2) {
4531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4532     return 0;
4533   }
4534   {
4535     try {
4536       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4537     } catch (std::out_of_range& e) {
4538       {
4539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4540       };
4541     } catch (std::exception& e) {
4542       {
4543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4544       };
4545     } catch (Dali::DaliException e) {
4546       {
4547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4548       };
4549     } catch (...) {
4550       {
4551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4552       };
4553     }
4554   }
4555
4556   jresult = (void *)result;
4557   return jresult;
4558 }
4559
4560
4561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4562   void * jresult ;
4563   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4564   Dali::Vector2 *arg2 = 0 ;
4565   Dali::Vector2 result;
4566
4567   arg1 = (Dali::Vector2 *)jarg1;
4568   arg2 = (Dali::Vector2 *)jarg2;
4569   if (!arg2) {
4570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4571     return 0;
4572   }
4573   {
4574     try {
4575       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4576     } catch (std::out_of_range& e) {
4577       {
4578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4579       };
4580     } catch (std::exception& e) {
4581       {
4582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4583       };
4584     } catch (Dali::DaliException e) {
4585       {
4586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4587       };
4588     } catch (...) {
4589       {
4590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4591       };
4592     }
4593   }
4594
4595   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4596   return jresult;
4597 }
4598
4599
4600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4601   void * jresult ;
4602   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4603   Dali::Vector2 *arg2 = 0 ;
4604   Dali::Vector2 *result = 0 ;
4605
4606   arg1 = (Dali::Vector2 *)jarg1;
4607   arg2 = (Dali::Vector2 *)jarg2;
4608   if (!arg2) {
4609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4610     return 0;
4611   }
4612   {
4613     try {
4614       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4615     } catch (std::out_of_range& e) {
4616       {
4617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4618       };
4619     } catch (std::exception& e) {
4620       {
4621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4622       };
4623     } catch (Dali::DaliException e) {
4624       {
4625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4626       };
4627     } catch (...) {
4628       {
4629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4630       };
4631     }
4632   }
4633
4634   jresult = (void *)result;
4635   return jresult;
4636 }
4637
4638
4639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4640   void * jresult ;
4641   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4642   Dali::Vector2 *arg2 = 0 ;
4643   Dali::Vector2 result;
4644
4645   arg1 = (Dali::Vector2 *)jarg1;
4646   arg2 = (Dali::Vector2 *)jarg2;
4647   if (!arg2) {
4648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4649     return 0;
4650   }
4651   {
4652     try {
4653       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4654     } catch (std::out_of_range& e) {
4655       {
4656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4657       };
4658     } catch (std::exception& e) {
4659       {
4660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4661       };
4662     } catch (Dali::DaliException e) {
4663       {
4664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4665       };
4666     } catch (...) {
4667       {
4668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4669       };
4670     }
4671   }
4672
4673   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4674   return jresult;
4675 }
4676
4677
4678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4679   void * jresult ;
4680   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4681   Dali::Vector2 *arg2 = 0 ;
4682   Dali::Vector2 *result = 0 ;
4683
4684   arg1 = (Dali::Vector2 *)jarg1;
4685   arg2 = (Dali::Vector2 *)jarg2;
4686   if (!arg2) {
4687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4688     return 0;
4689   }
4690   {
4691     try {
4692       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4693     } catch (std::out_of_range& e) {
4694       {
4695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4696       };
4697     } catch (std::exception& e) {
4698       {
4699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4700       };
4701     } catch (Dali::DaliException e) {
4702       {
4703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4704       };
4705     } catch (...) {
4706       {
4707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4708       };
4709     }
4710   }
4711
4712   jresult = (void *)result;
4713   return jresult;
4714 }
4715
4716
4717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4718   void * jresult ;
4719   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4720   Dali::Vector2 *arg2 = 0 ;
4721   Dali::Vector2 result;
4722
4723   arg1 = (Dali::Vector2 *)jarg1;
4724   arg2 = (Dali::Vector2 *)jarg2;
4725   if (!arg2) {
4726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4727     return 0;
4728   }
4729   {
4730     try {
4731       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4732     } catch (std::out_of_range& e) {
4733       {
4734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4735       };
4736     } catch (std::exception& e) {
4737       {
4738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4739       };
4740     } catch (Dali::DaliException e) {
4741       {
4742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4743       };
4744     } catch (...) {
4745       {
4746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4747       };
4748     }
4749   }
4750
4751   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4752   return jresult;
4753 }
4754
4755
4756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4757   void * jresult ;
4758   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4759   float arg2 ;
4760   Dali::Vector2 result;
4761
4762   arg1 = (Dali::Vector2 *)jarg1;
4763   arg2 = (float)jarg2;
4764   {
4765     try {
4766       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4767     } catch (std::out_of_range& e) {
4768       {
4769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4770       };
4771     } catch (std::exception& e) {
4772       {
4773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4774       };
4775     } catch (Dali::DaliException e) {
4776       {
4777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4778       };
4779     } catch (...) {
4780       {
4781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4782       };
4783     }
4784   }
4785
4786   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4787   return jresult;
4788 }
4789
4790
4791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4792   void * jresult ;
4793   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4794   Dali::Vector2 *arg2 = 0 ;
4795   Dali::Vector2 *result = 0 ;
4796
4797   arg1 = (Dali::Vector2 *)jarg1;
4798   arg2 = (Dali::Vector2 *)jarg2;
4799   if (!arg2) {
4800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4801     return 0;
4802   }
4803   {
4804     try {
4805       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4806     } catch (std::out_of_range& e) {
4807       {
4808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4809       };
4810     } catch (std::exception& e) {
4811       {
4812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4813       };
4814     } catch (Dali::DaliException e) {
4815       {
4816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4817       };
4818     } catch (...) {
4819       {
4820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4821       };
4822     }
4823   }
4824
4825   jresult = (void *)result;
4826   return jresult;
4827 }
4828
4829
4830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4831   void * jresult ;
4832   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4833   float arg2 ;
4834   Dali::Vector2 *result = 0 ;
4835
4836   arg1 = (Dali::Vector2 *)jarg1;
4837   arg2 = (float)jarg2;
4838   {
4839     try {
4840       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4841     } catch (std::out_of_range& e) {
4842       {
4843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4844       };
4845     } catch (std::exception& e) {
4846       {
4847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4848       };
4849     } catch (Dali::DaliException e) {
4850       {
4851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4852       };
4853     } catch (...) {
4854       {
4855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4856       };
4857     }
4858   }
4859
4860   jresult = (void *)result;
4861   return jresult;
4862 }
4863
4864
4865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4866   void * jresult ;
4867   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4868   Dali::Vector2 *arg2 = 0 ;
4869   Dali::Vector2 result;
4870
4871   arg1 = (Dali::Vector2 *)jarg1;
4872   arg2 = (Dali::Vector2 *)jarg2;
4873   if (!arg2) {
4874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4875     return 0;
4876   }
4877   {
4878     try {
4879       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4880     } catch (std::out_of_range& e) {
4881       {
4882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4883       };
4884     } catch (std::exception& e) {
4885       {
4886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4887       };
4888     } catch (Dali::DaliException e) {
4889       {
4890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4891       };
4892     } catch (...) {
4893       {
4894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4895       };
4896     }
4897   }
4898
4899   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4900   return jresult;
4901 }
4902
4903
4904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4905   void * jresult ;
4906   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4907   float arg2 ;
4908   Dali::Vector2 result;
4909
4910   arg1 = (Dali::Vector2 *)jarg1;
4911   arg2 = (float)jarg2;
4912   {
4913     try {
4914       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4915     } catch (std::out_of_range& e) {
4916       {
4917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4918       };
4919     } catch (std::exception& e) {
4920       {
4921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4922       };
4923     } catch (Dali::DaliException e) {
4924       {
4925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4926       };
4927     } catch (...) {
4928       {
4929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4930       };
4931     }
4932   }
4933
4934   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4935   return jresult;
4936 }
4937
4938
4939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4940   void * jresult ;
4941   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4942   Dali::Vector2 *arg2 = 0 ;
4943   Dali::Vector2 *result = 0 ;
4944
4945   arg1 = (Dali::Vector2 *)jarg1;
4946   arg2 = (Dali::Vector2 *)jarg2;
4947   if (!arg2) {
4948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4949     return 0;
4950   }
4951   {
4952     try {
4953       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4954     } catch (std::out_of_range& e) {
4955       {
4956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4957       };
4958     } catch (std::exception& e) {
4959       {
4960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4961       };
4962     } catch (Dali::DaliException e) {
4963       {
4964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4965       };
4966     } catch (...) {
4967       {
4968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4969       };
4970     }
4971   }
4972
4973   jresult = (void *)result;
4974   return jresult;
4975 }
4976
4977
4978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4979   void * jresult ;
4980   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4981   float arg2 ;
4982   Dali::Vector2 *result = 0 ;
4983
4984   arg1 = (Dali::Vector2 *)jarg1;
4985   arg2 = (float)jarg2;
4986   {
4987     try {
4988       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4989     } catch (std::out_of_range& e) {
4990       {
4991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4992       };
4993     } catch (std::exception& e) {
4994       {
4995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4996       };
4997     } catch (Dali::DaliException e) {
4998       {
4999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5000       };
5001     } catch (...) {
5002       {
5003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5004       };
5005     }
5006   }
5007
5008   jresult = (void *)result;
5009   return jresult;
5010 }
5011
5012
5013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5014   void * jresult ;
5015   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5016   Dali::Vector2 result;
5017
5018   arg1 = (Dali::Vector2 *)jarg1;
5019   {
5020     try {
5021       result = ((Dali::Vector2 const *)arg1)->operator -();
5022     } catch (std::out_of_range& e) {
5023       {
5024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5025       };
5026     } catch (std::exception& e) {
5027       {
5028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5029       };
5030     } catch (Dali::DaliException e) {
5031       {
5032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5033       };
5034     } catch (...) {
5035       {
5036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5037       };
5038     }
5039   }
5040
5041   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5042   return jresult;
5043 }
5044
5045
5046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5047   unsigned int jresult ;
5048   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5049   Dali::Vector2 *arg2 = 0 ;
5050   bool result;
5051
5052   arg1 = (Dali::Vector2 *)jarg1;
5053   arg2 = (Dali::Vector2 *)jarg2;
5054   if (!arg2) {
5055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5056     return 0;
5057   }
5058   {
5059     try {
5060       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5061     } catch (std::out_of_range& e) {
5062       {
5063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5064       };
5065     } catch (std::exception& e) {
5066       {
5067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5068       };
5069     } catch (Dali::DaliException e) {
5070       {
5071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5072       };
5073     } catch (...) {
5074       {
5075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5076       };
5077     }
5078   }
5079
5080   jresult = result;
5081   return jresult;
5082 }
5083
5084
5085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5086   unsigned int jresult ;
5087   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5088   Dali::Vector2 *arg2 = 0 ;
5089   bool result;
5090
5091   arg1 = (Dali::Vector2 *)jarg1;
5092   arg2 = (Dali::Vector2 *)jarg2;
5093   if (!arg2) {
5094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5095     return 0;
5096   }
5097   {
5098     try {
5099       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5100     } catch (std::out_of_range& e) {
5101       {
5102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5103       };
5104     } catch (std::exception& e) {
5105       {
5106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5107       };
5108     } catch (Dali::DaliException e) {
5109       {
5110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5111       };
5112     } catch (...) {
5113       {
5114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5115       };
5116     }
5117   }
5118
5119   jresult = result;
5120   return jresult;
5121 }
5122
5123
5124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5125   float jresult ;
5126   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5127   unsigned int arg2 ;
5128   float *result = 0 ;
5129
5130   arg1 = (Dali::Vector2 *)jarg1;
5131   arg2 = (unsigned int)jarg2;
5132   {
5133     try {
5134       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5135     } catch (std::out_of_range& e) {
5136       {
5137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5138       };
5139     } catch (std::exception& e) {
5140       {
5141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5142       };
5143     } catch (Dali::DaliException e) {
5144       {
5145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5146       };
5147     } catch (...) {
5148       {
5149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5150       };
5151     }
5152   }
5153
5154   jresult = *result;
5155   return jresult;
5156 }
5157
5158
5159 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5160   float jresult ;
5161   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5162   float result;
5163
5164   arg1 = (Dali::Vector2 *)jarg1;
5165   {
5166     try {
5167       result = (float)((Dali::Vector2 const *)arg1)->Length();
5168     } catch (std::out_of_range& e) {
5169       {
5170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5171       };
5172     } catch (std::exception& e) {
5173       {
5174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5175       };
5176     } catch (Dali::DaliException e) {
5177       {
5178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5179       };
5180     } catch (...) {
5181       {
5182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5183       };
5184     }
5185   }
5186
5187   jresult = result;
5188   return jresult;
5189 }
5190
5191
5192 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5193   float jresult ;
5194   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5195   float result;
5196
5197   arg1 = (Dali::Vector2 *)jarg1;
5198   {
5199     try {
5200       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5201     } catch (std::out_of_range& e) {
5202       {
5203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5204       };
5205     } catch (std::exception& e) {
5206       {
5207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5208       };
5209     } catch (Dali::DaliException e) {
5210       {
5211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5212       };
5213     } catch (...) {
5214       {
5215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5216       };
5217     }
5218   }
5219
5220   jresult = result;
5221   return jresult;
5222 }
5223
5224
5225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5226   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5227
5228   arg1 = (Dali::Vector2 *)jarg1;
5229   {
5230     try {
5231       (arg1)->Normalize();
5232     } catch (std::out_of_range& e) {
5233       {
5234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5235       };
5236     } catch (std::exception& e) {
5237       {
5238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5239       };
5240     } catch (Dali::DaliException e) {
5241       {
5242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5243       };
5244     } catch (...) {
5245       {
5246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5247       };
5248     }
5249   }
5250
5251 }
5252
5253
5254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5255   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5256   Dali::Vector2 *arg2 = 0 ;
5257   Dali::Vector2 *arg3 = 0 ;
5258
5259   arg1 = (Dali::Vector2 *)jarg1;
5260   arg2 = (Dali::Vector2 *)jarg2;
5261   if (!arg2) {
5262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5263     return ;
5264   }
5265   arg3 = (Dali::Vector2 *)jarg3;
5266   if (!arg3) {
5267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5268     return ;
5269   }
5270   {
5271     try {
5272       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5273     } catch (std::out_of_range& e) {
5274       {
5275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5276       };
5277     } catch (std::exception& e) {
5278       {
5279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5280       };
5281     } catch (Dali::DaliException e) {
5282       {
5283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5284       };
5285     } catch (...) {
5286       {
5287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5288       };
5289     }
5290   }
5291
5292 }
5293
5294
5295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5296   void * jresult ;
5297   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5298   float *result = 0 ;
5299
5300   arg1 = (Dali::Vector2 *)jarg1;
5301   {
5302     try {
5303       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5304     } catch (std::out_of_range& e) {
5305       {
5306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5307       };
5308     } catch (std::exception& e) {
5309       {
5310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5311       };
5312     } catch (Dali::DaliException e) {
5313       {
5314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5315       };
5316     } catch (...) {
5317       {
5318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5319       };
5320     }
5321   }
5322
5323   jresult = (void *)result;
5324   return jresult;
5325 }
5326
5327
5328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5329   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5330   float arg2 ;
5331
5332   arg1 = (Dali::Vector2 *)jarg1;
5333   arg2 = (float)jarg2;
5334   if (arg1) (arg1)->x = arg2;
5335 }
5336
5337
5338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5339   float jresult ;
5340   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5341   float result;
5342
5343   arg1 = (Dali::Vector2 *)jarg1;
5344   result = (float) ((arg1)->x);
5345   jresult = result;
5346   return jresult;
5347 }
5348
5349
5350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5351   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5352   float arg2 ;
5353
5354   arg1 = (Dali::Vector2 *)jarg1;
5355   arg2 = (float)jarg2;
5356   if (arg1) (arg1)->width = arg2;
5357 }
5358
5359
5360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5361   float jresult ;
5362   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5363   float result;
5364
5365   arg1 = (Dali::Vector2 *)jarg1;
5366   result = (float) ((arg1)->width);
5367   jresult = result;
5368   return jresult;
5369 }
5370
5371
5372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5373   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5374   float arg2 ;
5375
5376   arg1 = (Dali::Vector2 *)jarg1;
5377   arg2 = (float)jarg2;
5378   if (arg1) (arg1)->y = arg2;
5379 }
5380
5381
5382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5383   float jresult ;
5384   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5385   float result;
5386
5387   arg1 = (Dali::Vector2 *)jarg1;
5388   result = (float) ((arg1)->y);
5389   jresult = result;
5390   return jresult;
5391 }
5392
5393
5394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5395   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5396   float arg2 ;
5397
5398   arg1 = (Dali::Vector2 *)jarg1;
5399   arg2 = (float)jarg2;
5400   if (arg1) (arg1)->height = arg2;
5401 }
5402
5403
5404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5405   float jresult ;
5406   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5407   float result;
5408
5409   arg1 = (Dali::Vector2 *)jarg1;
5410   result = (float) ((arg1)->height);
5411   jresult = result;
5412   return jresult;
5413 }
5414
5415
5416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5417   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5418
5419   arg1 = (Dali::Vector2 *)jarg1;
5420   {
5421     try {
5422       delete arg1;
5423     } catch (std::out_of_range& e) {
5424       {
5425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5426       };
5427     } catch (std::exception& e) {
5428       {
5429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5430       };
5431     } catch (Dali::DaliException e) {
5432       {
5433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5434       };
5435     } catch (...) {
5436       {
5437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5438       };
5439     }
5440   }
5441
5442 }
5443
5444
5445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5446   void * jresult ;
5447   Dali::Vector2 *arg1 = 0 ;
5448   Dali::Vector2 *arg2 = 0 ;
5449   Dali::Vector2 result;
5450
5451   arg1 = (Dali::Vector2 *)jarg1;
5452   if (!arg1) {
5453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5454     return 0;
5455   }
5456   arg2 = (Dali::Vector2 *)jarg2;
5457   if (!arg2) {
5458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5459     return 0;
5460   }
5461   {
5462     try {
5463       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5464     } catch (std::out_of_range& e) {
5465       {
5466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5467       };
5468     } catch (std::exception& e) {
5469       {
5470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5471       };
5472     } catch (Dali::DaliException e) {
5473       {
5474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5475       };
5476     } catch (...) {
5477       {
5478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5479       };
5480     }
5481   }
5482
5483   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5484   return jresult;
5485 }
5486
5487
5488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5489   void * jresult ;
5490   Dali::Vector2 *arg1 = 0 ;
5491   Dali::Vector2 *arg2 = 0 ;
5492   Dali::Vector2 result;
5493
5494   arg1 = (Dali::Vector2 *)jarg1;
5495   if (!arg1) {
5496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5497     return 0;
5498   }
5499   arg2 = (Dali::Vector2 *)jarg2;
5500   if (!arg2) {
5501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5502     return 0;
5503   }
5504   {
5505     try {
5506       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5507     } catch (std::out_of_range& e) {
5508       {
5509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5510       };
5511     } catch (std::exception& e) {
5512       {
5513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5514       };
5515     } catch (Dali::DaliException e) {
5516       {
5517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5518       };
5519     } catch (...) {
5520       {
5521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5522       };
5523     }
5524   }
5525
5526   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5527   return jresult;
5528 }
5529
5530
5531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5532   void * jresult ;
5533   Dali::Vector2 *arg1 = 0 ;
5534   float *arg2 = 0 ;
5535   float *arg3 = 0 ;
5536   float temp2 ;
5537   float temp3 ;
5538   Dali::Vector2 result;
5539
5540   arg1 = (Dali::Vector2 *)jarg1;
5541   if (!arg1) {
5542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5543     return 0;
5544   }
5545   temp2 = (float)jarg2;
5546   arg2 = &temp2;
5547   temp3 = (float)jarg3;
5548   arg3 = &temp3;
5549   {
5550     try {
5551       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5552     } catch (std::out_of_range& e) {
5553       {
5554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5555       };
5556     } catch (std::exception& e) {
5557       {
5558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5559       };
5560     } catch (Dali::DaliException e) {
5561       {
5562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5563       };
5564     } catch (...) {
5565       {
5566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5567       };
5568     }
5569   }
5570
5571   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5572   return jresult;
5573 }
5574
5575
5576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5577   void * jresult ;
5578   Dali::Vector3 *result = 0 ;
5579
5580   {
5581     try {
5582       result = (Dali::Vector3 *)new Dali::Vector3();
5583     } catch (std::out_of_range& e) {
5584       {
5585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5586       };
5587     } catch (std::exception& e) {
5588       {
5589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5590       };
5591     } catch (Dali::DaliException e) {
5592       {
5593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5594       };
5595     } catch (...) {
5596       {
5597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5598       };
5599     }
5600   }
5601
5602   jresult = (void *)result;
5603   return jresult;
5604 }
5605
5606
5607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5608   void * jresult ;
5609   float arg1 ;
5610   float arg2 ;
5611   float arg3 ;
5612   Dali::Vector3 *result = 0 ;
5613
5614   arg1 = (float)jarg1;
5615   arg2 = (float)jarg2;
5616   arg3 = (float)jarg3;
5617   {
5618     try {
5619       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5620     } catch (std::out_of_range& e) {
5621       {
5622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5623       };
5624     } catch (std::exception& e) {
5625       {
5626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5627       };
5628     } catch (Dali::DaliException e) {
5629       {
5630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5631       };
5632     } catch (...) {
5633       {
5634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5635       };
5636     }
5637   }
5638
5639   jresult = (void *)result;
5640   return jresult;
5641 }
5642
5643
5644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5645   void * jresult ;
5646   float *arg1 = (float *) 0 ;
5647   Dali::Vector3 *result = 0 ;
5648
5649   arg1 = jarg1;
5650   {
5651     try {
5652       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5653     } catch (std::out_of_range& e) {
5654       {
5655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5656       };
5657     } catch (std::exception& e) {
5658       {
5659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5660       };
5661     } catch (Dali::DaliException e) {
5662       {
5663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5664       };
5665     } catch (...) {
5666       {
5667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5668       };
5669     }
5670   }
5671
5672   jresult = (void *)result;
5673
5674
5675   return jresult;
5676 }
5677
5678
5679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5680   void * jresult ;
5681   Dali::Vector2 *arg1 = 0 ;
5682   Dali::Vector3 *result = 0 ;
5683
5684   arg1 = (Dali::Vector2 *)jarg1;
5685   if (!arg1) {
5686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5687     return 0;
5688   }
5689   {
5690     try {
5691       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5692     } catch (std::out_of_range& e) {
5693       {
5694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5695       };
5696     } catch (std::exception& e) {
5697       {
5698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5699       };
5700     } catch (Dali::DaliException e) {
5701       {
5702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5703       };
5704     } catch (...) {
5705       {
5706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5707       };
5708     }
5709   }
5710
5711   jresult = (void *)result;
5712   return jresult;
5713 }
5714
5715
5716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5717   void * jresult ;
5718   Dali::Vector4 *arg1 = 0 ;
5719   Dali::Vector3 *result = 0 ;
5720
5721   arg1 = (Dali::Vector4 *)jarg1;
5722   if (!arg1) {
5723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5724     return 0;
5725   }
5726   {
5727     try {
5728       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5729     } catch (std::out_of_range& e) {
5730       {
5731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5732       };
5733     } catch (std::exception& e) {
5734       {
5735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5736       };
5737     } catch (Dali::DaliException e) {
5738       {
5739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5740       };
5741     } catch (...) {
5742       {
5743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5744       };
5745     }
5746   }
5747
5748   jresult = (void *)result;
5749   return jresult;
5750 }
5751
5752
5753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5754   void * jresult ;
5755   Dali::Vector3 *result = 0 ;
5756
5757   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5758   jresult = (void *)result;
5759   return jresult;
5760 }
5761
5762
5763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5764   void * jresult ;
5765   Dali::Vector3 *result = 0 ;
5766
5767   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5768   jresult = (void *)result;
5769   return jresult;
5770 }
5771
5772
5773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5774   void * jresult ;
5775   Dali::Vector3 *result = 0 ;
5776
5777   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5778   jresult = (void *)result;
5779   return jresult;
5780 }
5781
5782
5783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5784   void * jresult ;
5785   Dali::Vector3 *result = 0 ;
5786
5787   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5788   jresult = (void *)result;
5789   return jresult;
5790 }
5791
5792
5793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5794   void * jresult ;
5795   Dali::Vector3 *result = 0 ;
5796
5797   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5798   jresult = (void *)result;
5799   return jresult;
5800 }
5801
5802
5803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5804   void * jresult ;
5805   Dali::Vector3 *result = 0 ;
5806
5807   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5808   jresult = (void *)result;
5809   return jresult;
5810 }
5811
5812
5813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5814   void * jresult ;
5815   Dali::Vector3 *result = 0 ;
5816
5817   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5818   jresult = (void *)result;
5819   return jresult;
5820 }
5821
5822
5823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5824   void * jresult ;
5825   Dali::Vector3 *result = 0 ;
5826
5827   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5828   jresult = (void *)result;
5829   return jresult;
5830 }
5831
5832
5833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5834   void * jresult ;
5835   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5836   float *arg2 = (float *) 0 ;
5837   Dali::Vector3 *result = 0 ;
5838
5839   arg1 = (Dali::Vector3 *)jarg1;
5840   arg2 = jarg2;
5841   {
5842     try {
5843       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5844     } catch (std::out_of_range& e) {
5845       {
5846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5847       };
5848     } catch (std::exception& e) {
5849       {
5850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5851       };
5852     } catch (Dali::DaliException e) {
5853       {
5854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5855       };
5856     } catch (...) {
5857       {
5858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5859       };
5860     }
5861   }
5862
5863   jresult = (void *)result;
5864
5865
5866   return jresult;
5867 }
5868
5869
5870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5871   void * jresult ;
5872   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5873   Dali::Vector2 *arg2 = 0 ;
5874   Dali::Vector3 *result = 0 ;
5875
5876   arg1 = (Dali::Vector3 *)jarg1;
5877   arg2 = (Dali::Vector2 *)jarg2;
5878   if (!arg2) {
5879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5880     return 0;
5881   }
5882   {
5883     try {
5884       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5885     } catch (std::out_of_range& e) {
5886       {
5887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5888       };
5889     } catch (std::exception& e) {
5890       {
5891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5892       };
5893     } catch (Dali::DaliException e) {
5894       {
5895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5896       };
5897     } catch (...) {
5898       {
5899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5900       };
5901     }
5902   }
5903
5904   jresult = (void *)result;
5905   return jresult;
5906 }
5907
5908
5909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5910   void * jresult ;
5911   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5912   Dali::Vector4 *arg2 = 0 ;
5913   Dali::Vector3 *result = 0 ;
5914
5915   arg1 = (Dali::Vector3 *)jarg1;
5916   arg2 = (Dali::Vector4 *)jarg2;
5917   if (!arg2) {
5918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5919     return 0;
5920   }
5921   {
5922     try {
5923       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5924     } catch (std::out_of_range& e) {
5925       {
5926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5927       };
5928     } catch (std::exception& e) {
5929       {
5930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5931       };
5932     } catch (Dali::DaliException e) {
5933       {
5934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5935       };
5936     } catch (...) {
5937       {
5938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5939       };
5940     }
5941   }
5942
5943   jresult = (void *)result;
5944   return jresult;
5945 }
5946
5947
5948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5949   void * jresult ;
5950   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5951   Dali::Vector3 *arg2 = 0 ;
5952   Dali::Vector3 result;
5953
5954   arg1 = (Dali::Vector3 *)jarg1;
5955   arg2 = (Dali::Vector3 *)jarg2;
5956   if (!arg2) {
5957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5958     return 0;
5959   }
5960   {
5961     try {
5962       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5963     } catch (std::out_of_range& e) {
5964       {
5965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5966       };
5967     } catch (std::exception& e) {
5968       {
5969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5970       };
5971     } catch (Dali::DaliException e) {
5972       {
5973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5974       };
5975     } catch (...) {
5976       {
5977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5978       };
5979     }
5980   }
5981
5982   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5983   return jresult;
5984 }
5985
5986
5987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5988   void * jresult ;
5989   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5990   Dali::Vector3 *arg2 = 0 ;
5991   Dali::Vector3 *result = 0 ;
5992
5993   arg1 = (Dali::Vector3 *)jarg1;
5994   arg2 = (Dali::Vector3 *)jarg2;
5995   if (!arg2) {
5996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5997     return 0;
5998   }
5999   {
6000     try {
6001       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6002     } catch (std::out_of_range& e) {
6003       {
6004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6005       };
6006     } catch (std::exception& e) {
6007       {
6008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6009       };
6010     } catch (Dali::DaliException e) {
6011       {
6012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6013       };
6014     } catch (...) {
6015       {
6016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6017       };
6018     }
6019   }
6020
6021   jresult = (void *)result;
6022   return jresult;
6023 }
6024
6025
6026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6027   void * jresult ;
6028   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6029   Dali::Vector3 *arg2 = 0 ;
6030   Dali::Vector3 result;
6031
6032   arg1 = (Dali::Vector3 *)jarg1;
6033   arg2 = (Dali::Vector3 *)jarg2;
6034   if (!arg2) {
6035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6036     return 0;
6037   }
6038   {
6039     try {
6040       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6041     } catch (std::out_of_range& e) {
6042       {
6043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6044       };
6045     } catch (std::exception& e) {
6046       {
6047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6048       };
6049     } catch (Dali::DaliException e) {
6050       {
6051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6052       };
6053     } catch (...) {
6054       {
6055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6056       };
6057     }
6058   }
6059
6060   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6061   return jresult;
6062 }
6063
6064
6065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6066   void * jresult ;
6067   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6068   Dali::Vector3 *arg2 = 0 ;
6069   Dali::Vector3 *result = 0 ;
6070
6071   arg1 = (Dali::Vector3 *)jarg1;
6072   arg2 = (Dali::Vector3 *)jarg2;
6073   if (!arg2) {
6074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6075     return 0;
6076   }
6077   {
6078     try {
6079       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6080     } catch (std::out_of_range& e) {
6081       {
6082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6083       };
6084     } catch (std::exception& e) {
6085       {
6086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6087       };
6088     } catch (Dali::DaliException e) {
6089       {
6090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6091       };
6092     } catch (...) {
6093       {
6094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6095       };
6096     }
6097   }
6098
6099   jresult = (void *)result;
6100   return jresult;
6101 }
6102
6103
6104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6105   void * jresult ;
6106   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6107   Dali::Vector3 *arg2 = 0 ;
6108   Dali::Vector3 result;
6109
6110   arg1 = (Dali::Vector3 *)jarg1;
6111   arg2 = (Dali::Vector3 *)jarg2;
6112   if (!arg2) {
6113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6114     return 0;
6115   }
6116   {
6117     try {
6118       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6119     } catch (std::out_of_range& e) {
6120       {
6121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6122       };
6123     } catch (std::exception& e) {
6124       {
6125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6126       };
6127     } catch (Dali::DaliException e) {
6128       {
6129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6130       };
6131     } catch (...) {
6132       {
6133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6134       };
6135     }
6136   }
6137
6138   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6139   return jresult;
6140 }
6141
6142
6143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6144   void * jresult ;
6145   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6146   float arg2 ;
6147   Dali::Vector3 result;
6148
6149   arg1 = (Dali::Vector3 *)jarg1;
6150   arg2 = (float)jarg2;
6151   {
6152     try {
6153       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6154     } catch (std::out_of_range& e) {
6155       {
6156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6157       };
6158     } catch (std::exception& e) {
6159       {
6160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6161       };
6162     } catch (Dali::DaliException e) {
6163       {
6164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6165       };
6166     } catch (...) {
6167       {
6168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6169       };
6170     }
6171   }
6172
6173   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6174   return jresult;
6175 }
6176
6177
6178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6179   void * jresult ;
6180   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6181   Dali::Vector3 *arg2 = 0 ;
6182   Dali::Vector3 *result = 0 ;
6183
6184   arg1 = (Dali::Vector3 *)jarg1;
6185   arg2 = (Dali::Vector3 *)jarg2;
6186   if (!arg2) {
6187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6188     return 0;
6189   }
6190   {
6191     try {
6192       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6193     } catch (std::out_of_range& e) {
6194       {
6195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6196       };
6197     } catch (std::exception& e) {
6198       {
6199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6200       };
6201     } catch (Dali::DaliException e) {
6202       {
6203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6204       };
6205     } catch (...) {
6206       {
6207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6208       };
6209     }
6210   }
6211
6212   jresult = (void *)result;
6213   return jresult;
6214 }
6215
6216
6217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6218   void * jresult ;
6219   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6220   float arg2 ;
6221   Dali::Vector3 *result = 0 ;
6222
6223   arg1 = (Dali::Vector3 *)jarg1;
6224   arg2 = (float)jarg2;
6225   {
6226     try {
6227       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6228     } catch (std::out_of_range& e) {
6229       {
6230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6231       };
6232     } catch (std::exception& e) {
6233       {
6234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6235       };
6236     } catch (Dali::DaliException e) {
6237       {
6238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6239       };
6240     } catch (...) {
6241       {
6242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6243       };
6244     }
6245   }
6246
6247   jresult = (void *)result;
6248   return jresult;
6249 }
6250
6251
6252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6253   void * jresult ;
6254   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6255   Dali::Quaternion *arg2 = 0 ;
6256   Dali::Vector3 *result = 0 ;
6257
6258   arg1 = (Dali::Vector3 *)jarg1;
6259   arg2 = (Dali::Quaternion *)jarg2;
6260   if (!arg2) {
6261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6262     return 0;
6263   }
6264   {
6265     try {
6266       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6267     } catch (std::out_of_range& e) {
6268       {
6269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6270       };
6271     } catch (std::exception& e) {
6272       {
6273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6274       };
6275     } catch (Dali::DaliException e) {
6276       {
6277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6278       };
6279     } catch (...) {
6280       {
6281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6282       };
6283     }
6284   }
6285
6286   jresult = (void *)result;
6287   return jresult;
6288 }
6289
6290
6291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6292   void * jresult ;
6293   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6294   Dali::Vector3 *arg2 = 0 ;
6295   Dali::Vector3 result;
6296
6297   arg1 = (Dali::Vector3 *)jarg1;
6298   arg2 = (Dali::Vector3 *)jarg2;
6299   if (!arg2) {
6300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6301     return 0;
6302   }
6303   {
6304     try {
6305       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6306     } catch (std::out_of_range& e) {
6307       {
6308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6309       };
6310     } catch (std::exception& e) {
6311       {
6312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6313       };
6314     } catch (Dali::DaliException e) {
6315       {
6316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6317       };
6318     } catch (...) {
6319       {
6320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6321       };
6322     }
6323   }
6324
6325   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6326   return jresult;
6327 }
6328
6329
6330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6331   void * jresult ;
6332   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6333   float arg2 ;
6334   Dali::Vector3 result;
6335
6336   arg1 = (Dali::Vector3 *)jarg1;
6337   arg2 = (float)jarg2;
6338   {
6339     try {
6340       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6341     } catch (std::out_of_range& e) {
6342       {
6343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6344       };
6345     } catch (std::exception& e) {
6346       {
6347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6348       };
6349     } catch (Dali::DaliException e) {
6350       {
6351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6352       };
6353     } catch (...) {
6354       {
6355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6356       };
6357     }
6358   }
6359
6360   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6361   return jresult;
6362 }
6363
6364
6365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6366   void * jresult ;
6367   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6368   Dali::Vector3 *arg2 = 0 ;
6369   Dali::Vector3 *result = 0 ;
6370
6371   arg1 = (Dali::Vector3 *)jarg1;
6372   arg2 = (Dali::Vector3 *)jarg2;
6373   if (!arg2) {
6374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6375     return 0;
6376   }
6377   {
6378     try {
6379       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6380     } catch (std::out_of_range& e) {
6381       {
6382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6383       };
6384     } catch (std::exception& e) {
6385       {
6386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6387       };
6388     } catch (Dali::DaliException e) {
6389       {
6390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6391       };
6392     } catch (...) {
6393       {
6394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6395       };
6396     }
6397   }
6398
6399   jresult = (void *)result;
6400   return jresult;
6401 }
6402
6403
6404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6405   void * jresult ;
6406   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6407   float arg2 ;
6408   Dali::Vector3 *result = 0 ;
6409
6410   arg1 = (Dali::Vector3 *)jarg1;
6411   arg2 = (float)jarg2;
6412   {
6413     try {
6414       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6415     } catch (std::out_of_range& e) {
6416       {
6417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6418       };
6419     } catch (std::exception& e) {
6420       {
6421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6422       };
6423     } catch (Dali::DaliException e) {
6424       {
6425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6426       };
6427     } catch (...) {
6428       {
6429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6430       };
6431     }
6432   }
6433
6434   jresult = (void *)result;
6435   return jresult;
6436 }
6437
6438
6439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6440   void * jresult ;
6441   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6442   Dali::Vector3 result;
6443
6444   arg1 = (Dali::Vector3 *)jarg1;
6445   {
6446     try {
6447       result = ((Dali::Vector3 const *)arg1)->operator -();
6448     } catch (std::out_of_range& e) {
6449       {
6450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6451       };
6452     } catch (std::exception& e) {
6453       {
6454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6455       };
6456     } catch (Dali::DaliException e) {
6457       {
6458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6459       };
6460     } catch (...) {
6461       {
6462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6463       };
6464     }
6465   }
6466
6467   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6468   return jresult;
6469 }
6470
6471
6472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6473   unsigned int jresult ;
6474   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6475   Dali::Vector3 *arg2 = 0 ;
6476   bool result;
6477
6478   arg1 = (Dali::Vector3 *)jarg1;
6479   arg2 = (Dali::Vector3 *)jarg2;
6480   if (!arg2) {
6481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6482     return 0;
6483   }
6484   {
6485     try {
6486       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6487     } catch (std::out_of_range& e) {
6488       {
6489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6490       };
6491     } catch (std::exception& e) {
6492       {
6493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6494       };
6495     } catch (Dali::DaliException e) {
6496       {
6497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6498       };
6499     } catch (...) {
6500       {
6501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6502       };
6503     }
6504   }
6505
6506   jresult = result;
6507   return jresult;
6508 }
6509
6510
6511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6512   unsigned int jresult ;
6513   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6514   Dali::Vector3 *arg2 = 0 ;
6515   bool result;
6516
6517   arg1 = (Dali::Vector3 *)jarg1;
6518   arg2 = (Dali::Vector3 *)jarg2;
6519   if (!arg2) {
6520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6521     return 0;
6522   }
6523   {
6524     try {
6525       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6526     } catch (std::out_of_range& e) {
6527       {
6528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6529       };
6530     } catch (std::exception& e) {
6531       {
6532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6533       };
6534     } catch (Dali::DaliException e) {
6535       {
6536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6537       };
6538     } catch (...) {
6539       {
6540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6541       };
6542     }
6543   }
6544
6545   jresult = result;
6546   return jresult;
6547 }
6548
6549
6550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6551   float jresult ;
6552   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6553   unsigned int arg2 ;
6554   float *result = 0 ;
6555
6556   arg1 = (Dali::Vector3 *)jarg1;
6557   arg2 = (unsigned int)jarg2;
6558   {
6559     try {
6560       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6561     } catch (std::out_of_range& e) {
6562       {
6563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6564       };
6565     } catch (std::exception& e) {
6566       {
6567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6568       };
6569     } catch (Dali::DaliException e) {
6570       {
6571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6572       };
6573     } catch (...) {
6574       {
6575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6576       };
6577     }
6578   }
6579
6580   jresult = *result;
6581   return jresult;
6582 }
6583
6584
6585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6586   float jresult ;
6587   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6588   Dali::Vector3 *arg2 = 0 ;
6589   float result;
6590
6591   arg1 = (Dali::Vector3 *)jarg1;
6592   arg2 = (Dali::Vector3 *)jarg2;
6593   if (!arg2) {
6594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6595     return 0;
6596   }
6597   {
6598     try {
6599       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6600     } catch (std::out_of_range& e) {
6601       {
6602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6603       };
6604     } catch (std::exception& e) {
6605       {
6606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6607       };
6608     } catch (Dali::DaliException e) {
6609       {
6610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6611       };
6612     } catch (...) {
6613       {
6614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6615       };
6616     }
6617   }
6618
6619   jresult = result;
6620   return jresult;
6621 }
6622
6623
6624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6625   void * jresult ;
6626   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6627   Dali::Vector3 *arg2 = 0 ;
6628   Dali::Vector3 result;
6629
6630   arg1 = (Dali::Vector3 *)jarg1;
6631   arg2 = (Dali::Vector3 *)jarg2;
6632   if (!arg2) {
6633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6634     return 0;
6635   }
6636   {
6637     try {
6638       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6639     } catch (std::out_of_range& e) {
6640       {
6641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6642       };
6643     } catch (std::exception& e) {
6644       {
6645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6646       };
6647     } catch (Dali::DaliException e) {
6648       {
6649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6650       };
6651     } catch (...) {
6652       {
6653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6654       };
6655     }
6656   }
6657
6658   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6659   return jresult;
6660 }
6661
6662
6663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6664   float jresult ;
6665   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6666   float result;
6667
6668   arg1 = (Dali::Vector3 *)jarg1;
6669   {
6670     try {
6671       result = (float)((Dali::Vector3 const *)arg1)->Length();
6672     } catch (std::out_of_range& e) {
6673       {
6674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6675       };
6676     } catch (std::exception& e) {
6677       {
6678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6679       };
6680     } catch (Dali::DaliException e) {
6681       {
6682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6683       };
6684     } catch (...) {
6685       {
6686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6687       };
6688     }
6689   }
6690
6691   jresult = result;
6692   return jresult;
6693 }
6694
6695
6696 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6697   float jresult ;
6698   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6699   float result;
6700
6701   arg1 = (Dali::Vector3 *)jarg1;
6702   {
6703     try {
6704       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6705     } catch (std::out_of_range& e) {
6706       {
6707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6708       };
6709     } catch (std::exception& e) {
6710       {
6711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6712       };
6713     } catch (Dali::DaliException e) {
6714       {
6715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6716       };
6717     } catch (...) {
6718       {
6719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6720       };
6721     }
6722   }
6723
6724   jresult = result;
6725   return jresult;
6726 }
6727
6728
6729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6730   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6731
6732   arg1 = (Dali::Vector3 *)jarg1;
6733   {
6734     try {
6735       (arg1)->Normalize();
6736     } catch (std::out_of_range& e) {
6737       {
6738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6739       };
6740     } catch (std::exception& e) {
6741       {
6742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6743       };
6744     } catch (Dali::DaliException e) {
6745       {
6746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6747       };
6748     } catch (...) {
6749       {
6750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6751       };
6752     }
6753   }
6754
6755 }
6756
6757
6758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6759   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6760   Dali::Vector3 *arg2 = 0 ;
6761   Dali::Vector3 *arg3 = 0 ;
6762
6763   arg1 = (Dali::Vector3 *)jarg1;
6764   arg2 = (Dali::Vector3 *)jarg2;
6765   if (!arg2) {
6766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6767     return ;
6768   }
6769   arg3 = (Dali::Vector3 *)jarg3;
6770   if (!arg3) {
6771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6772     return ;
6773   }
6774   {
6775     try {
6776       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6777     } catch (std::out_of_range& e) {
6778       {
6779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6780       };
6781     } catch (std::exception& e) {
6782       {
6783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6784       };
6785     } catch (Dali::DaliException e) {
6786       {
6787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6788       };
6789     } catch (...) {
6790       {
6791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6792       };
6793     }
6794   }
6795
6796 }
6797
6798
6799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6800   void * jresult ;
6801   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6802   float *result = 0 ;
6803
6804   arg1 = (Dali::Vector3 *)jarg1;
6805   {
6806     try {
6807       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6808     } catch (std::out_of_range& e) {
6809       {
6810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6811       };
6812     } catch (std::exception& e) {
6813       {
6814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6815       };
6816     } catch (Dali::DaliException e) {
6817       {
6818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6819       };
6820     } catch (...) {
6821       {
6822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6823       };
6824     }
6825   }
6826
6827   jresult = (void *)result;
6828   return jresult;
6829 }
6830
6831
6832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6833   void * jresult ;
6834   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6835   Dali::Vector2 *result = 0 ;
6836
6837   arg1 = (Dali::Vector3 *)jarg1;
6838   {
6839     try {
6840       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6841     } catch (std::out_of_range& e) {
6842       {
6843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6844       };
6845     } catch (std::exception& e) {
6846       {
6847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6848       };
6849     } catch (Dali::DaliException e) {
6850       {
6851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6852       };
6853     } catch (...) {
6854       {
6855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6856       };
6857     }
6858   }
6859
6860   jresult = (void *)result;
6861   return jresult;
6862 }
6863
6864
6865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6866   void * jresult ;
6867   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6868   Dali::Vector2 *result = 0 ;
6869
6870   arg1 = (Dali::Vector3 *)jarg1;
6871   {
6872     try {
6873       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6874     } catch (std::out_of_range& e) {
6875       {
6876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6877       };
6878     } catch (std::exception& e) {
6879       {
6880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6881       };
6882     } catch (Dali::DaliException e) {
6883       {
6884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6885       };
6886     } catch (...) {
6887       {
6888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6889       };
6890     }
6891   }
6892
6893   jresult = (void *)result;
6894   return jresult;
6895 }
6896
6897
6898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6899   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6900   float arg2 ;
6901
6902   arg1 = (Dali::Vector3 *)jarg1;
6903   arg2 = (float)jarg2;
6904   if (arg1) (arg1)->x = arg2;
6905 }
6906
6907
6908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6909   float jresult ;
6910   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6911   float result;
6912
6913   arg1 = (Dali::Vector3 *)jarg1;
6914   result = (float) ((arg1)->x);
6915   jresult = result;
6916   return jresult;
6917 }
6918
6919
6920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6921   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6922   float arg2 ;
6923
6924   arg1 = (Dali::Vector3 *)jarg1;
6925   arg2 = (float)jarg2;
6926   if (arg1) (arg1)->width = arg2;
6927 }
6928
6929
6930 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6931   float jresult ;
6932   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6933   float result;
6934
6935   arg1 = (Dali::Vector3 *)jarg1;
6936   result = (float) ((arg1)->width);
6937   jresult = result;
6938   return jresult;
6939 }
6940
6941
6942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6943   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6944   float arg2 ;
6945
6946   arg1 = (Dali::Vector3 *)jarg1;
6947   arg2 = (float)jarg2;
6948   if (arg1) (arg1)->r = arg2;
6949 }
6950
6951
6952 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6953   float jresult ;
6954   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6955   float result;
6956
6957   arg1 = (Dali::Vector3 *)jarg1;
6958   result = (float) ((arg1)->r);
6959   jresult = result;
6960   return jresult;
6961 }
6962
6963
6964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6965   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6966   float arg2 ;
6967
6968   arg1 = (Dali::Vector3 *)jarg1;
6969   arg2 = (float)jarg2;
6970   if (arg1) (arg1)->y = arg2;
6971 }
6972
6973
6974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6975   float jresult ;
6976   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6977   float result;
6978
6979   arg1 = (Dali::Vector3 *)jarg1;
6980   result = (float) ((arg1)->y);
6981   jresult = result;
6982   return jresult;
6983 }
6984
6985
6986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6987   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6988   float arg2 ;
6989
6990   arg1 = (Dali::Vector3 *)jarg1;
6991   arg2 = (float)jarg2;
6992   if (arg1) (arg1)->height = arg2;
6993 }
6994
6995
6996 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6997   float jresult ;
6998   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6999   float result;
7000
7001   arg1 = (Dali::Vector3 *)jarg1;
7002   result = (float) ((arg1)->height);
7003   jresult = result;
7004   return jresult;
7005 }
7006
7007
7008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7009   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7010   float arg2 ;
7011
7012   arg1 = (Dali::Vector3 *)jarg1;
7013   arg2 = (float)jarg2;
7014   if (arg1) (arg1)->g = arg2;
7015 }
7016
7017
7018 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7019   float jresult ;
7020   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7021   float result;
7022
7023   arg1 = (Dali::Vector3 *)jarg1;
7024   result = (float) ((arg1)->g);
7025   jresult = result;
7026   return jresult;
7027 }
7028
7029
7030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7031   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7032   float arg2 ;
7033
7034   arg1 = (Dali::Vector3 *)jarg1;
7035   arg2 = (float)jarg2;
7036   if (arg1) (arg1)->z = arg2;
7037 }
7038
7039
7040 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7041   float jresult ;
7042   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7043   float result;
7044
7045   arg1 = (Dali::Vector3 *)jarg1;
7046   result = (float) ((arg1)->z);
7047   jresult = result;
7048   return jresult;
7049 }
7050
7051
7052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7053   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7054   float arg2 ;
7055
7056   arg1 = (Dali::Vector3 *)jarg1;
7057   arg2 = (float)jarg2;
7058   if (arg1) (arg1)->depth = arg2;
7059 }
7060
7061
7062 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7063   float jresult ;
7064   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7065   float result;
7066
7067   arg1 = (Dali::Vector3 *)jarg1;
7068   result = (float) ((arg1)->depth);
7069   jresult = result;
7070   return jresult;
7071 }
7072
7073
7074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7075   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7076   float arg2 ;
7077
7078   arg1 = (Dali::Vector3 *)jarg1;
7079   arg2 = (float)jarg2;
7080   if (arg1) (arg1)->b = arg2;
7081 }
7082
7083
7084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7085   float jresult ;
7086   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7087   float result;
7088
7089   arg1 = (Dali::Vector3 *)jarg1;
7090   result = (float) ((arg1)->b);
7091   jresult = result;
7092   return jresult;
7093 }
7094
7095
7096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7097   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7098
7099   arg1 = (Dali::Vector3 *)jarg1;
7100   {
7101     try {
7102       delete arg1;
7103     } catch (std::out_of_range& e) {
7104       {
7105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7106       };
7107     } catch (std::exception& e) {
7108       {
7109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7110       };
7111     } catch (Dali::DaliException e) {
7112       {
7113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7114       };
7115     } catch (...) {
7116       {
7117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7118       };
7119     }
7120   }
7121
7122 }
7123
7124
7125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7126   void * jresult ;
7127   Dali::Vector3 *arg1 = 0 ;
7128   Dali::Vector3 *arg2 = 0 ;
7129   Dali::Vector3 result;
7130
7131   arg1 = (Dali::Vector3 *)jarg1;
7132   if (!arg1) {
7133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7134     return 0;
7135   }
7136   arg2 = (Dali::Vector3 *)jarg2;
7137   if (!arg2) {
7138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7139     return 0;
7140   }
7141   {
7142     try {
7143       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7144     } catch (std::out_of_range& e) {
7145       {
7146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7147       };
7148     } catch (std::exception& e) {
7149       {
7150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7151       };
7152     } catch (Dali::DaliException e) {
7153       {
7154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7155       };
7156     } catch (...) {
7157       {
7158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7159       };
7160     }
7161   }
7162
7163   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7164   return jresult;
7165 }
7166
7167
7168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7169   void * jresult ;
7170   Dali::Vector3 *arg1 = 0 ;
7171   Dali::Vector3 *arg2 = 0 ;
7172   Dali::Vector3 result;
7173
7174   arg1 = (Dali::Vector3 *)jarg1;
7175   if (!arg1) {
7176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7177     return 0;
7178   }
7179   arg2 = (Dali::Vector3 *)jarg2;
7180   if (!arg2) {
7181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7182     return 0;
7183   }
7184   {
7185     try {
7186       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7187     } catch (std::out_of_range& e) {
7188       {
7189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7190       };
7191     } catch (std::exception& e) {
7192       {
7193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7194       };
7195     } catch (Dali::DaliException e) {
7196       {
7197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7198       };
7199     } catch (...) {
7200       {
7201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7202       };
7203     }
7204   }
7205
7206   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7207   return jresult;
7208 }
7209
7210
7211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7212   void * jresult ;
7213   Dali::Vector3 *arg1 = 0 ;
7214   float *arg2 = 0 ;
7215   float *arg3 = 0 ;
7216   float temp2 ;
7217   float temp3 ;
7218   Dali::Vector3 result;
7219
7220   arg1 = (Dali::Vector3 *)jarg1;
7221   if (!arg1) {
7222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7223     return 0;
7224   }
7225   temp2 = (float)jarg2;
7226   arg2 = &temp2;
7227   temp3 = (float)jarg3;
7228   arg3 = &temp3;
7229   {
7230     try {
7231       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7232     } catch (std::out_of_range& e) {
7233       {
7234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7235       };
7236     } catch (std::exception& e) {
7237       {
7238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7239       };
7240     } catch (Dali::DaliException e) {
7241       {
7242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7243       };
7244     } catch (...) {
7245       {
7246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7247       };
7248     }
7249   }
7250
7251   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7252   return jresult;
7253 }
7254
7255
7256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7257   void * jresult ;
7258   Dali::Vector4 *result = 0 ;
7259
7260   {
7261     try {
7262       result = (Dali::Vector4 *)new Dali::Vector4();
7263     } catch (std::out_of_range& e) {
7264       {
7265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7266       };
7267     } catch (std::exception& e) {
7268       {
7269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7270       };
7271     } catch (Dali::DaliException e) {
7272       {
7273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7274       };
7275     } catch (...) {
7276       {
7277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7278       };
7279     }
7280   }
7281
7282   jresult = (void *)result;
7283   return jresult;
7284 }
7285
7286
7287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7288   void * jresult ;
7289   float arg1 ;
7290   float arg2 ;
7291   float arg3 ;
7292   float arg4 ;
7293   Dali::Vector4 *result = 0 ;
7294
7295   arg1 = (float)jarg1;
7296   arg2 = (float)jarg2;
7297   arg3 = (float)jarg3;
7298   arg4 = (float)jarg4;
7299   {
7300     try {
7301       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7302     } catch (std::out_of_range& e) {
7303       {
7304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7305       };
7306     } catch (std::exception& e) {
7307       {
7308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7309       };
7310     } catch (Dali::DaliException e) {
7311       {
7312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7313       };
7314     } catch (...) {
7315       {
7316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7317       };
7318     }
7319   }
7320
7321   jresult = (void *)result;
7322   return jresult;
7323 }
7324
7325
7326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7327   void * jresult ;
7328   float *arg1 = (float *) 0 ;
7329   Dali::Vector4 *result = 0 ;
7330
7331   arg1 = jarg1;
7332   {
7333     try {
7334       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7335     } catch (std::out_of_range& e) {
7336       {
7337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7338       };
7339     } catch (std::exception& e) {
7340       {
7341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7342       };
7343     } catch (Dali::DaliException e) {
7344       {
7345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7346       };
7347     } catch (...) {
7348       {
7349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7350       };
7351     }
7352   }
7353
7354   jresult = (void *)result;
7355
7356
7357   return jresult;
7358 }
7359
7360
7361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7362   void * jresult ;
7363   Dali::Vector2 *arg1 = 0 ;
7364   Dali::Vector4 *result = 0 ;
7365
7366   arg1 = (Dali::Vector2 *)jarg1;
7367   if (!arg1) {
7368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7369     return 0;
7370   }
7371   {
7372     try {
7373       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7374     } catch (std::out_of_range& e) {
7375       {
7376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7377       };
7378     } catch (std::exception& e) {
7379       {
7380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7381       };
7382     } catch (Dali::DaliException e) {
7383       {
7384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7385       };
7386     } catch (...) {
7387       {
7388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7389       };
7390     }
7391   }
7392
7393   jresult = (void *)result;
7394   return jresult;
7395 }
7396
7397
7398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7399   void * jresult ;
7400   Dali::Vector3 *arg1 = 0 ;
7401   Dali::Vector4 *result = 0 ;
7402
7403   arg1 = (Dali::Vector3 *)jarg1;
7404   if (!arg1) {
7405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7406     return 0;
7407   }
7408   {
7409     try {
7410       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7411     } catch (std::out_of_range& e) {
7412       {
7413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7414       };
7415     } catch (std::exception& e) {
7416       {
7417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7418       };
7419     } catch (Dali::DaliException e) {
7420       {
7421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7422       };
7423     } catch (...) {
7424       {
7425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7426       };
7427     }
7428   }
7429
7430   jresult = (void *)result;
7431   return jresult;
7432 }
7433
7434
7435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7436   void * jresult ;
7437   Dali::Vector4 *result = 0 ;
7438
7439   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7440   jresult = (void *)result;
7441   return jresult;
7442 }
7443
7444
7445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7446   void * jresult ;
7447   Dali::Vector4 *result = 0 ;
7448
7449   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7450   jresult = (void *)result;
7451   return jresult;
7452 }
7453
7454
7455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7456   void * jresult ;
7457   Dali::Vector4 *result = 0 ;
7458
7459   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7460   jresult = (void *)result;
7461   return jresult;
7462 }
7463
7464
7465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7466   void * jresult ;
7467   Dali::Vector4 *result = 0 ;
7468
7469   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7470   jresult = (void *)result;
7471   return jresult;
7472 }
7473
7474
7475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7476   void * jresult ;
7477   Dali::Vector4 *result = 0 ;
7478
7479   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7480   jresult = (void *)result;
7481   return jresult;
7482 }
7483
7484
7485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7486   void * jresult ;
7487   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7488   float *arg2 = (float *) 0 ;
7489   Dali::Vector4 *result = 0 ;
7490
7491   arg1 = (Dali::Vector4 *)jarg1;
7492   arg2 = jarg2;
7493   {
7494     try {
7495       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7496     } catch (std::out_of_range& e) {
7497       {
7498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7499       };
7500     } catch (std::exception& e) {
7501       {
7502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7503       };
7504     } catch (Dali::DaliException e) {
7505       {
7506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7507       };
7508     } catch (...) {
7509       {
7510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7511       };
7512     }
7513   }
7514
7515   jresult = (void *)result;
7516
7517
7518   return jresult;
7519 }
7520
7521
7522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7523   void * jresult ;
7524   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7525   Dali::Vector2 *arg2 = 0 ;
7526   Dali::Vector4 *result = 0 ;
7527
7528   arg1 = (Dali::Vector4 *)jarg1;
7529   arg2 = (Dali::Vector2 *)jarg2;
7530   if (!arg2) {
7531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7532     return 0;
7533   }
7534   {
7535     try {
7536       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7537     } catch (std::out_of_range& e) {
7538       {
7539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7540       };
7541     } catch (std::exception& e) {
7542       {
7543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7544       };
7545     } catch (Dali::DaliException e) {
7546       {
7547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7548       };
7549     } catch (...) {
7550       {
7551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7552       };
7553     }
7554   }
7555
7556   jresult = (void *)result;
7557   return jresult;
7558 }
7559
7560
7561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7562   void * jresult ;
7563   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7564   Dali::Vector3 *arg2 = 0 ;
7565   Dali::Vector4 *result = 0 ;
7566
7567   arg1 = (Dali::Vector4 *)jarg1;
7568   arg2 = (Dali::Vector3 *)jarg2;
7569   if (!arg2) {
7570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7571     return 0;
7572   }
7573   {
7574     try {
7575       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7576     } catch (std::out_of_range& e) {
7577       {
7578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7579       };
7580     } catch (std::exception& e) {
7581       {
7582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7583       };
7584     } catch (Dali::DaliException e) {
7585       {
7586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7587       };
7588     } catch (...) {
7589       {
7590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7591       };
7592     }
7593   }
7594
7595   jresult = (void *)result;
7596   return jresult;
7597 }
7598
7599
7600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7601   void * jresult ;
7602   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7603   Dali::Vector4 *arg2 = 0 ;
7604   Dali::Vector4 result;
7605
7606   arg1 = (Dali::Vector4 *)jarg1;
7607   arg2 = (Dali::Vector4 *)jarg2;
7608   if (!arg2) {
7609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7610     return 0;
7611   }
7612   {
7613     try {
7614       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7615     } catch (std::out_of_range& e) {
7616       {
7617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7618       };
7619     } catch (std::exception& e) {
7620       {
7621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7622       };
7623     } catch (Dali::DaliException e) {
7624       {
7625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7626       };
7627     } catch (...) {
7628       {
7629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7630       };
7631     }
7632   }
7633
7634   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7635   return jresult;
7636 }
7637
7638
7639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7640   void * jresult ;
7641   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7642   Dali::Vector4 *arg2 = 0 ;
7643   Dali::Vector4 *result = 0 ;
7644
7645   arg1 = (Dali::Vector4 *)jarg1;
7646   arg2 = (Dali::Vector4 *)jarg2;
7647   if (!arg2) {
7648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7649     return 0;
7650   }
7651   {
7652     try {
7653       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7654     } catch (std::out_of_range& e) {
7655       {
7656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7657       };
7658     } catch (std::exception& e) {
7659       {
7660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7661       };
7662     } catch (Dali::DaliException e) {
7663       {
7664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7665       };
7666     } catch (...) {
7667       {
7668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7669       };
7670     }
7671   }
7672
7673   jresult = (void *)result;
7674   return jresult;
7675 }
7676
7677
7678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7679   void * jresult ;
7680   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7681   Dali::Vector4 *arg2 = 0 ;
7682   Dali::Vector4 result;
7683
7684   arg1 = (Dali::Vector4 *)jarg1;
7685   arg2 = (Dali::Vector4 *)jarg2;
7686   if (!arg2) {
7687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7688     return 0;
7689   }
7690   {
7691     try {
7692       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7693     } catch (std::out_of_range& e) {
7694       {
7695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7696       };
7697     } catch (std::exception& e) {
7698       {
7699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7700       };
7701     } catch (Dali::DaliException e) {
7702       {
7703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7704       };
7705     } catch (...) {
7706       {
7707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7708       };
7709     }
7710   }
7711
7712   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7713   return jresult;
7714 }
7715
7716
7717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7718   void * jresult ;
7719   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7720   Dali::Vector4 *arg2 = 0 ;
7721   Dali::Vector4 *result = 0 ;
7722
7723   arg1 = (Dali::Vector4 *)jarg1;
7724   arg2 = (Dali::Vector4 *)jarg2;
7725   if (!arg2) {
7726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7727     return 0;
7728   }
7729   {
7730     try {
7731       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7732     } catch (std::out_of_range& e) {
7733       {
7734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7735       };
7736     } catch (std::exception& e) {
7737       {
7738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7739       };
7740     } catch (Dali::DaliException e) {
7741       {
7742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7743       };
7744     } catch (...) {
7745       {
7746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7747       };
7748     }
7749   }
7750
7751   jresult = (void *)result;
7752   return jresult;
7753 }
7754
7755
7756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7757   void * jresult ;
7758   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7759   Dali::Vector4 *arg2 = 0 ;
7760   Dali::Vector4 result;
7761
7762   arg1 = (Dali::Vector4 *)jarg1;
7763   arg2 = (Dali::Vector4 *)jarg2;
7764   if (!arg2) {
7765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7766     return 0;
7767   }
7768   {
7769     try {
7770       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7771     } catch (std::out_of_range& e) {
7772       {
7773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7774       };
7775     } catch (std::exception& e) {
7776       {
7777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7778       };
7779     } catch (Dali::DaliException e) {
7780       {
7781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7782       };
7783     } catch (...) {
7784       {
7785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7786       };
7787     }
7788   }
7789
7790   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7791   return jresult;
7792 }
7793
7794
7795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7796   void * jresult ;
7797   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7798   float arg2 ;
7799   Dali::Vector4 result;
7800
7801   arg1 = (Dali::Vector4 *)jarg1;
7802   arg2 = (float)jarg2;
7803   {
7804     try {
7805       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7806     } catch (std::out_of_range& e) {
7807       {
7808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7809       };
7810     } catch (std::exception& e) {
7811       {
7812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7813       };
7814     } catch (Dali::DaliException e) {
7815       {
7816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7817       };
7818     } catch (...) {
7819       {
7820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7821       };
7822     }
7823   }
7824
7825   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7826   return jresult;
7827 }
7828
7829
7830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7831   void * jresult ;
7832   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7833   Dali::Vector4 *arg2 = 0 ;
7834   Dali::Vector4 *result = 0 ;
7835
7836   arg1 = (Dali::Vector4 *)jarg1;
7837   arg2 = (Dali::Vector4 *)jarg2;
7838   if (!arg2) {
7839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7840     return 0;
7841   }
7842   {
7843     try {
7844       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7845     } catch (std::out_of_range& e) {
7846       {
7847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7848       };
7849     } catch (std::exception& e) {
7850       {
7851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7852       };
7853     } catch (Dali::DaliException e) {
7854       {
7855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7856       };
7857     } catch (...) {
7858       {
7859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7860       };
7861     }
7862   }
7863
7864   jresult = (void *)result;
7865   return jresult;
7866 }
7867
7868
7869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7870   void * jresult ;
7871   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7872   float arg2 ;
7873   Dali::Vector4 *result = 0 ;
7874
7875   arg1 = (Dali::Vector4 *)jarg1;
7876   arg2 = (float)jarg2;
7877   {
7878     try {
7879       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7880     } catch (std::out_of_range& e) {
7881       {
7882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7883       };
7884     } catch (std::exception& e) {
7885       {
7886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7887       };
7888     } catch (Dali::DaliException e) {
7889       {
7890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7891       };
7892     } catch (...) {
7893       {
7894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7895       };
7896     }
7897   }
7898
7899   jresult = (void *)result;
7900   return jresult;
7901 }
7902
7903
7904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7905   void * jresult ;
7906   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7907   Dali::Vector4 *arg2 = 0 ;
7908   Dali::Vector4 result;
7909
7910   arg1 = (Dali::Vector4 *)jarg1;
7911   arg2 = (Dali::Vector4 *)jarg2;
7912   if (!arg2) {
7913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7914     return 0;
7915   }
7916   {
7917     try {
7918       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7919     } catch (std::out_of_range& e) {
7920       {
7921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7922       };
7923     } catch (std::exception& e) {
7924       {
7925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7926       };
7927     } catch (Dali::DaliException e) {
7928       {
7929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7930       };
7931     } catch (...) {
7932       {
7933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7934       };
7935     }
7936   }
7937
7938   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7939   return jresult;
7940 }
7941
7942
7943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7944   void * jresult ;
7945   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7946   float arg2 ;
7947   Dali::Vector4 result;
7948
7949   arg1 = (Dali::Vector4 *)jarg1;
7950   arg2 = (float)jarg2;
7951   {
7952     try {
7953       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7954     } catch (std::out_of_range& e) {
7955       {
7956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7957       };
7958     } catch (std::exception& e) {
7959       {
7960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7961       };
7962     } catch (Dali::DaliException e) {
7963       {
7964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7965       };
7966     } catch (...) {
7967       {
7968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7969       };
7970     }
7971   }
7972
7973   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7974   return jresult;
7975 }
7976
7977
7978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7979   void * jresult ;
7980   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7981   Dali::Vector4 *arg2 = 0 ;
7982   Dali::Vector4 *result = 0 ;
7983
7984   arg1 = (Dali::Vector4 *)jarg1;
7985   arg2 = (Dali::Vector4 *)jarg2;
7986   if (!arg2) {
7987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7988     return 0;
7989   }
7990   {
7991     try {
7992       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7993     } catch (std::out_of_range& e) {
7994       {
7995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7996       };
7997     } catch (std::exception& e) {
7998       {
7999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8000       };
8001     } catch (Dali::DaliException e) {
8002       {
8003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8004       };
8005     } catch (...) {
8006       {
8007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8008       };
8009     }
8010   }
8011
8012   jresult = (void *)result;
8013   return jresult;
8014 }
8015
8016
8017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8018   void * jresult ;
8019   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8020   float arg2 ;
8021   Dali::Vector4 *result = 0 ;
8022
8023   arg1 = (Dali::Vector4 *)jarg1;
8024   arg2 = (float)jarg2;
8025   {
8026     try {
8027       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8028     } catch (std::out_of_range& e) {
8029       {
8030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8031       };
8032     } catch (std::exception& e) {
8033       {
8034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8035       };
8036     } catch (Dali::DaliException e) {
8037       {
8038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8039       };
8040     } catch (...) {
8041       {
8042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8043       };
8044     }
8045   }
8046
8047   jresult = (void *)result;
8048   return jresult;
8049 }
8050
8051
8052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8053   void * jresult ;
8054   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8055   Dali::Vector4 result;
8056
8057   arg1 = (Dali::Vector4 *)jarg1;
8058   {
8059     try {
8060       result = ((Dali::Vector4 const *)arg1)->operator -();
8061     } catch (std::out_of_range& e) {
8062       {
8063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8064       };
8065     } catch (std::exception& e) {
8066       {
8067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8068       };
8069     } catch (Dali::DaliException e) {
8070       {
8071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8072       };
8073     } catch (...) {
8074       {
8075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8076       };
8077     }
8078   }
8079
8080   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8081   return jresult;
8082 }
8083
8084
8085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8086   unsigned int jresult ;
8087   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8088   Dali::Vector4 *arg2 = 0 ;
8089   bool result;
8090
8091   arg1 = (Dali::Vector4 *)jarg1;
8092   arg2 = (Dali::Vector4 *)jarg2;
8093   if (!arg2) {
8094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8095     return 0;
8096   }
8097   {
8098     try {
8099       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8100     } catch (std::out_of_range& e) {
8101       {
8102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8103       };
8104     } catch (std::exception& e) {
8105       {
8106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8107       };
8108     } catch (Dali::DaliException e) {
8109       {
8110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8111       };
8112     } catch (...) {
8113       {
8114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8115       };
8116     }
8117   }
8118
8119   jresult = result;
8120   return jresult;
8121 }
8122
8123
8124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8125   unsigned int jresult ;
8126   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8127   Dali::Vector4 *arg2 = 0 ;
8128   bool result;
8129
8130   arg1 = (Dali::Vector4 *)jarg1;
8131   arg2 = (Dali::Vector4 *)jarg2;
8132   if (!arg2) {
8133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8134     return 0;
8135   }
8136   {
8137     try {
8138       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8139     } catch (std::out_of_range& e) {
8140       {
8141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8142       };
8143     } catch (std::exception& e) {
8144       {
8145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8146       };
8147     } catch (Dali::DaliException e) {
8148       {
8149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8150       };
8151     } catch (...) {
8152       {
8153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8154       };
8155     }
8156   }
8157
8158   jresult = result;
8159   return jresult;
8160 }
8161
8162
8163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8164   float jresult ;
8165   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8166   unsigned int arg2 ;
8167   float *result = 0 ;
8168
8169   arg1 = (Dali::Vector4 *)jarg1;
8170   arg2 = (unsigned int)jarg2;
8171   {
8172     try {
8173       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8174     } catch (std::out_of_range& e) {
8175       {
8176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8177       };
8178     } catch (std::exception& e) {
8179       {
8180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8181       };
8182     } catch (Dali::DaliException e) {
8183       {
8184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8185       };
8186     } catch (...) {
8187       {
8188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8189       };
8190     }
8191   }
8192
8193   jresult = *result;
8194   return jresult;
8195 }
8196
8197
8198 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8199   float jresult ;
8200   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8201   Dali::Vector3 *arg2 = 0 ;
8202   float result;
8203
8204   arg1 = (Dali::Vector4 *)jarg1;
8205   arg2 = (Dali::Vector3 *)jarg2;
8206   if (!arg2) {
8207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8208     return 0;
8209   }
8210   {
8211     try {
8212       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8213     } catch (std::out_of_range& e) {
8214       {
8215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8216       };
8217     } catch (std::exception& e) {
8218       {
8219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8220       };
8221     } catch (Dali::DaliException e) {
8222       {
8223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8224       };
8225     } catch (...) {
8226       {
8227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8228       };
8229     }
8230   }
8231
8232   jresult = result;
8233   return jresult;
8234 }
8235
8236
8237 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8238   float jresult ;
8239   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8240   Dali::Vector4 *arg2 = 0 ;
8241   float result;
8242
8243   arg1 = (Dali::Vector4 *)jarg1;
8244   arg2 = (Dali::Vector4 *)jarg2;
8245   if (!arg2) {
8246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8247     return 0;
8248   }
8249   {
8250     try {
8251       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8252     } catch (std::out_of_range& e) {
8253       {
8254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8255       };
8256     } catch (std::exception& e) {
8257       {
8258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8259       };
8260     } catch (Dali::DaliException e) {
8261       {
8262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8263       };
8264     } catch (...) {
8265       {
8266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8267       };
8268     }
8269   }
8270
8271   jresult = result;
8272   return jresult;
8273 }
8274
8275
8276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8277   float jresult ;
8278   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8279   Dali::Vector4 *arg2 = 0 ;
8280   float result;
8281
8282   arg1 = (Dali::Vector4 *)jarg1;
8283   arg2 = (Dali::Vector4 *)jarg2;
8284   if (!arg2) {
8285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8286     return 0;
8287   }
8288   {
8289     try {
8290       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8291     } catch (std::out_of_range& e) {
8292       {
8293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8294       };
8295     } catch (std::exception& e) {
8296       {
8297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8298       };
8299     } catch (Dali::DaliException e) {
8300       {
8301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8302       };
8303     } catch (...) {
8304       {
8305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8306       };
8307     }
8308   }
8309
8310   jresult = result;
8311   return jresult;
8312 }
8313
8314
8315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8316   void * jresult ;
8317   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8318   Dali::Vector4 *arg2 = 0 ;
8319   Dali::Vector4 result;
8320
8321   arg1 = (Dali::Vector4 *)jarg1;
8322   arg2 = (Dali::Vector4 *)jarg2;
8323   if (!arg2) {
8324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8325     return 0;
8326   }
8327   {
8328     try {
8329       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8330     } catch (std::out_of_range& e) {
8331       {
8332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8333       };
8334     } catch (std::exception& e) {
8335       {
8336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8337       };
8338     } catch (Dali::DaliException e) {
8339       {
8340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8341       };
8342     } catch (...) {
8343       {
8344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8345       };
8346     }
8347   }
8348
8349   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8350   return jresult;
8351 }
8352
8353
8354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8355   float jresult ;
8356   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8357   float result;
8358
8359   arg1 = (Dali::Vector4 *)jarg1;
8360   {
8361     try {
8362       result = (float)((Dali::Vector4 const *)arg1)->Length();
8363     } catch (std::out_of_range& e) {
8364       {
8365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8366       };
8367     } catch (std::exception& e) {
8368       {
8369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8370       };
8371     } catch (Dali::DaliException e) {
8372       {
8373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8374       };
8375     } catch (...) {
8376       {
8377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8378       };
8379     }
8380   }
8381
8382   jresult = result;
8383   return jresult;
8384 }
8385
8386
8387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8388   float jresult ;
8389   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8390   float result;
8391
8392   arg1 = (Dali::Vector4 *)jarg1;
8393   {
8394     try {
8395       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8396     } catch (std::out_of_range& e) {
8397       {
8398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8399       };
8400     } catch (std::exception& e) {
8401       {
8402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8403       };
8404     } catch (Dali::DaliException e) {
8405       {
8406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8407       };
8408     } catch (...) {
8409       {
8410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8411       };
8412     }
8413   }
8414
8415   jresult = result;
8416   return jresult;
8417 }
8418
8419
8420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8421   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8422
8423   arg1 = (Dali::Vector4 *)jarg1;
8424   {
8425     try {
8426       (arg1)->Normalize();
8427     } catch (std::out_of_range& e) {
8428       {
8429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8430       };
8431     } catch (std::exception& e) {
8432       {
8433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8434       };
8435     } catch (Dali::DaliException e) {
8436       {
8437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8438       };
8439     } catch (...) {
8440       {
8441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8442       };
8443     }
8444   }
8445
8446 }
8447
8448
8449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8450   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8451   Dali::Vector4 *arg2 = 0 ;
8452   Dali::Vector4 *arg3 = 0 ;
8453
8454   arg1 = (Dali::Vector4 *)jarg1;
8455   arg2 = (Dali::Vector4 *)jarg2;
8456   if (!arg2) {
8457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8458     return ;
8459   }
8460   arg3 = (Dali::Vector4 *)jarg3;
8461   if (!arg3) {
8462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8463     return ;
8464   }
8465   {
8466     try {
8467       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8468     } catch (std::out_of_range& e) {
8469       {
8470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8471       };
8472     } catch (std::exception& e) {
8473       {
8474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8475       };
8476     } catch (Dali::DaliException e) {
8477       {
8478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8479       };
8480     } catch (...) {
8481       {
8482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8483       };
8484     }
8485   }
8486
8487 }
8488
8489
8490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8491   void * jresult ;
8492   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8493   float *result = 0 ;
8494
8495   arg1 = (Dali::Vector4 *)jarg1;
8496   {
8497     try {
8498       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8499     } catch (std::out_of_range& e) {
8500       {
8501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8502       };
8503     } catch (std::exception& e) {
8504       {
8505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8506       };
8507     } catch (Dali::DaliException e) {
8508       {
8509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8510       };
8511     } catch (...) {
8512       {
8513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8514       };
8515     }
8516   }
8517
8518   jresult = (void *)result;
8519   return jresult;
8520 }
8521
8522
8523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8524   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8525   float arg2 ;
8526
8527   arg1 = (Dali::Vector4 *)jarg1;
8528   arg2 = (float)jarg2;
8529   if (arg1) (arg1)->x = arg2;
8530 }
8531
8532
8533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8534   float jresult ;
8535   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8536   float result;
8537
8538   arg1 = (Dali::Vector4 *)jarg1;
8539   result = (float) ((arg1)->x);
8540   jresult = result;
8541   return jresult;
8542 }
8543
8544
8545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8546   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8547   float arg2 ;
8548
8549   arg1 = (Dali::Vector4 *)jarg1;
8550   arg2 = (float)jarg2;
8551   if (arg1) (arg1)->r = arg2;
8552 }
8553
8554
8555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8556   float jresult ;
8557   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8558   float result;
8559
8560   arg1 = (Dali::Vector4 *)jarg1;
8561   result = (float) ((arg1)->r);
8562   jresult = result;
8563   return jresult;
8564 }
8565
8566
8567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8568   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8569   float arg2 ;
8570
8571   arg1 = (Dali::Vector4 *)jarg1;
8572   arg2 = (float)jarg2;
8573   if (arg1) (arg1)->s = arg2;
8574 }
8575
8576
8577 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8578   float jresult ;
8579   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8580   float result;
8581
8582   arg1 = (Dali::Vector4 *)jarg1;
8583   result = (float) ((arg1)->s);
8584   jresult = result;
8585   return jresult;
8586 }
8587
8588
8589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8590   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8591   float arg2 ;
8592
8593   arg1 = (Dali::Vector4 *)jarg1;
8594   arg2 = (float)jarg2;
8595   if (arg1) (arg1)->y = arg2;
8596 }
8597
8598
8599 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8600   float jresult ;
8601   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8602   float result;
8603
8604   arg1 = (Dali::Vector4 *)jarg1;
8605   result = (float) ((arg1)->y);
8606   jresult = result;
8607   return jresult;
8608 }
8609
8610
8611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8612   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8613   float arg2 ;
8614
8615   arg1 = (Dali::Vector4 *)jarg1;
8616   arg2 = (float)jarg2;
8617   if (arg1) (arg1)->g = arg2;
8618 }
8619
8620
8621 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8622   float jresult ;
8623   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8624   float result;
8625
8626   arg1 = (Dali::Vector4 *)jarg1;
8627   result = (float) ((arg1)->g);
8628   jresult = result;
8629   return jresult;
8630 }
8631
8632
8633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8634   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8635   float arg2 ;
8636
8637   arg1 = (Dali::Vector4 *)jarg1;
8638   arg2 = (float)jarg2;
8639   if (arg1) (arg1)->t = arg2;
8640 }
8641
8642
8643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8644   float jresult ;
8645   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8646   float result;
8647
8648   arg1 = (Dali::Vector4 *)jarg1;
8649   result = (float) ((arg1)->t);
8650   jresult = result;
8651   return jresult;
8652 }
8653
8654
8655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8656   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8657   float arg2 ;
8658
8659   arg1 = (Dali::Vector4 *)jarg1;
8660   arg2 = (float)jarg2;
8661   if (arg1) (arg1)->z = arg2;
8662 }
8663
8664
8665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8666   float jresult ;
8667   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8668   float result;
8669
8670   arg1 = (Dali::Vector4 *)jarg1;
8671   result = (float) ((arg1)->z);
8672   jresult = result;
8673   return jresult;
8674 }
8675
8676
8677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8678   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8679   float arg2 ;
8680
8681   arg1 = (Dali::Vector4 *)jarg1;
8682   arg2 = (float)jarg2;
8683   if (arg1) (arg1)->b = arg2;
8684 }
8685
8686
8687 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8688   float jresult ;
8689   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8690   float result;
8691
8692   arg1 = (Dali::Vector4 *)jarg1;
8693   result = (float) ((arg1)->b);
8694   jresult = result;
8695   return jresult;
8696 }
8697
8698
8699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8700   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8701   float arg2 ;
8702
8703   arg1 = (Dali::Vector4 *)jarg1;
8704   arg2 = (float)jarg2;
8705   if (arg1) (arg1)->p = arg2;
8706 }
8707
8708
8709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8710   float jresult ;
8711   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8712   float result;
8713
8714   arg1 = (Dali::Vector4 *)jarg1;
8715   result = (float) ((arg1)->p);
8716   jresult = result;
8717   return jresult;
8718 }
8719
8720
8721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8722   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8723   float arg2 ;
8724
8725   arg1 = (Dali::Vector4 *)jarg1;
8726   arg2 = (float)jarg2;
8727   if (arg1) (arg1)->w = arg2;
8728 }
8729
8730
8731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8732   float jresult ;
8733   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8734   float result;
8735
8736   arg1 = (Dali::Vector4 *)jarg1;
8737   result = (float) ((arg1)->w);
8738   jresult = result;
8739   return jresult;
8740 }
8741
8742
8743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8744   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8745   float arg2 ;
8746
8747   arg1 = (Dali::Vector4 *)jarg1;
8748   arg2 = (float)jarg2;
8749   if (arg1) (arg1)->a = arg2;
8750 }
8751
8752
8753 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8754   float jresult ;
8755   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8756   float result;
8757
8758   arg1 = (Dali::Vector4 *)jarg1;
8759   result = (float) ((arg1)->a);
8760   jresult = result;
8761   return jresult;
8762 }
8763
8764
8765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8766   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8767   float arg2 ;
8768
8769   arg1 = (Dali::Vector4 *)jarg1;
8770   arg2 = (float)jarg2;
8771   if (arg1) (arg1)->q = arg2;
8772 }
8773
8774
8775 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8776   float jresult ;
8777   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8778   float result;
8779
8780   arg1 = (Dali::Vector4 *)jarg1;
8781   result = (float) ((arg1)->q);
8782   jresult = result;
8783   return jresult;
8784 }
8785
8786
8787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8788   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8789
8790   arg1 = (Dali::Vector4 *)jarg1;
8791   {
8792     try {
8793       delete arg1;
8794     } catch (std::out_of_range& e) {
8795       {
8796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8797       };
8798     } catch (std::exception& e) {
8799       {
8800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8801       };
8802     } catch (Dali::DaliException e) {
8803       {
8804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8805       };
8806     } catch (...) {
8807       {
8808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8809       };
8810     }
8811   }
8812
8813 }
8814
8815
8816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8817   void * jresult ;
8818   Dali::Vector4 *arg1 = 0 ;
8819   Dali::Vector4 *arg2 = 0 ;
8820   Dali::Vector4 result;
8821
8822   arg1 = (Dali::Vector4 *)jarg1;
8823   if (!arg1) {
8824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8825     return 0;
8826   }
8827   arg2 = (Dali::Vector4 *)jarg2;
8828   if (!arg2) {
8829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8830     return 0;
8831   }
8832   {
8833     try {
8834       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8835     } catch (std::out_of_range& e) {
8836       {
8837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8838       };
8839     } catch (std::exception& e) {
8840       {
8841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8842       };
8843     } catch (Dali::DaliException e) {
8844       {
8845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8846       };
8847     } catch (...) {
8848       {
8849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8850       };
8851     }
8852   }
8853
8854   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8855   return jresult;
8856 }
8857
8858
8859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8860   void * jresult ;
8861   Dali::Vector4 *arg1 = 0 ;
8862   Dali::Vector4 *arg2 = 0 ;
8863   Dali::Vector4 result;
8864
8865   arg1 = (Dali::Vector4 *)jarg1;
8866   if (!arg1) {
8867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8868     return 0;
8869   }
8870   arg2 = (Dali::Vector4 *)jarg2;
8871   if (!arg2) {
8872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8873     return 0;
8874   }
8875   {
8876     try {
8877       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8878     } catch (std::out_of_range& e) {
8879       {
8880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8881       };
8882     } catch (std::exception& e) {
8883       {
8884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8885       };
8886     } catch (Dali::DaliException e) {
8887       {
8888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8889       };
8890     } catch (...) {
8891       {
8892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8893       };
8894     }
8895   }
8896
8897   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8898   return jresult;
8899 }
8900
8901
8902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8903   void * jresult ;
8904   Dali::Vector4 *arg1 = 0 ;
8905   float *arg2 = 0 ;
8906   float *arg3 = 0 ;
8907   float temp2 ;
8908   float temp3 ;
8909   Dali::Vector4 result;
8910
8911   arg1 = (Dali::Vector4 *)jarg1;
8912   if (!arg1) {
8913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8914     return 0;
8915   }
8916   temp2 = (float)jarg2;
8917   arg2 = &temp2;
8918   temp3 = (float)jarg3;
8919   arg3 = &temp3;
8920   {
8921     try {
8922       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8923     } catch (std::out_of_range& e) {
8924       {
8925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8926       };
8927     } catch (std::exception& e) {
8928       {
8929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8930       };
8931     } catch (Dali::DaliException e) {
8932       {
8933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8934       };
8935     } catch (...) {
8936       {
8937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8938       };
8939     }
8940   }
8941
8942   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8943   return jresult;
8944 }
8945
8946
8947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8948   void * jresult ;
8949   Dali::Uint16Pair *result = 0 ;
8950
8951   {
8952     try {
8953       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8954     } catch (std::out_of_range& e) {
8955       {
8956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8957       };
8958     } catch (std::exception& e) {
8959       {
8960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8961       };
8962     } catch (Dali::DaliException e) {
8963       {
8964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8965       };
8966     } catch (...) {
8967       {
8968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8969       };
8970     }
8971   }
8972
8973   jresult = (void *)result;
8974   return jresult;
8975 }
8976
8977
8978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8979   void * jresult ;
8980   uint32_t arg1 ;
8981   uint32_t arg2 ;
8982   Dali::Uint16Pair *result = 0 ;
8983
8984   arg1 = (uint32_t)jarg1;
8985   arg2 = (uint32_t)jarg2;
8986   {
8987     try {
8988       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8989     } catch (std::out_of_range& e) {
8990       {
8991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8992       };
8993     } catch (std::exception& e) {
8994       {
8995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8996       };
8997     } catch (Dali::DaliException e) {
8998       {
8999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9000       };
9001     } catch (...) {
9002       {
9003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9004       };
9005     }
9006   }
9007
9008   jresult = (void *)result;
9009   return jresult;
9010 }
9011
9012
9013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9014   void * jresult ;
9015   Dali::Uint16Pair *arg1 = 0 ;
9016   Dali::Uint16Pair *result = 0 ;
9017
9018   arg1 = (Dali::Uint16Pair *)jarg1;
9019   if (!arg1) {
9020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9021     return 0;
9022   }
9023   {
9024     try {
9025       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9026     } catch (std::out_of_range& e) {
9027       {
9028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9029       };
9030     } catch (std::exception& e) {
9031       {
9032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9033       };
9034     } catch (Dali::DaliException e) {
9035       {
9036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9037       };
9038     } catch (...) {
9039       {
9040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9041       };
9042     }
9043   }
9044
9045   jresult = (void *)result;
9046   return jresult;
9047 }
9048
9049
9050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9051   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9052   uint16_t arg2 ;
9053
9054   arg1 = (Dali::Uint16Pair *)jarg1;
9055   arg2 = (uint16_t)jarg2;
9056   {
9057     try {
9058       (arg1)->SetWidth(arg2);
9059     } catch (std::out_of_range& e) {
9060       {
9061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9062       };
9063     } catch (std::exception& e) {
9064       {
9065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9066       };
9067     } catch (Dali::DaliException e) {
9068       {
9069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9070       };
9071     } catch (...) {
9072       {
9073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9074       };
9075     }
9076   }
9077
9078 }
9079
9080
9081 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9082   unsigned short jresult ;
9083   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9084   uint16_t result;
9085
9086   arg1 = (Dali::Uint16Pair *)jarg1;
9087   {
9088     try {
9089       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9090     } catch (std::out_of_range& e) {
9091       {
9092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9093       };
9094     } catch (std::exception& e) {
9095       {
9096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9097       };
9098     } catch (Dali::DaliException e) {
9099       {
9100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9101       };
9102     } catch (...) {
9103       {
9104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9105       };
9106     }
9107   }
9108
9109   jresult = result;
9110   return jresult;
9111 }
9112
9113
9114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9115   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9116   uint16_t arg2 ;
9117
9118   arg1 = (Dali::Uint16Pair *)jarg1;
9119   arg2 = (uint16_t)jarg2;
9120   {
9121     try {
9122       (arg1)->SetHeight(arg2);
9123     } catch (std::out_of_range& e) {
9124       {
9125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9126       };
9127     } catch (std::exception& e) {
9128       {
9129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9130       };
9131     } catch (Dali::DaliException e) {
9132       {
9133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9134       };
9135     } catch (...) {
9136       {
9137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9138       };
9139     }
9140   }
9141
9142 }
9143
9144
9145 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9146   unsigned short jresult ;
9147   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9148   uint16_t result;
9149
9150   arg1 = (Dali::Uint16Pair *)jarg1;
9151   {
9152     try {
9153       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9154     } catch (std::out_of_range& e) {
9155       {
9156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9157       };
9158     } catch (std::exception& e) {
9159       {
9160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9161       };
9162     } catch (Dali::DaliException e) {
9163       {
9164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9165       };
9166     } catch (...) {
9167       {
9168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9169       };
9170     }
9171   }
9172
9173   jresult = result;
9174   return jresult;
9175 }
9176
9177
9178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9179   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9180   uint16_t arg2 ;
9181
9182   arg1 = (Dali::Uint16Pair *)jarg1;
9183   arg2 = (uint16_t)jarg2;
9184   {
9185     try {
9186       (arg1)->SetX(arg2);
9187     } catch (std::out_of_range& e) {
9188       {
9189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9190       };
9191     } catch (std::exception& e) {
9192       {
9193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9194       };
9195     } catch (Dali::DaliException e) {
9196       {
9197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9198       };
9199     } catch (...) {
9200       {
9201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9202       };
9203     }
9204   }
9205
9206 }
9207
9208
9209 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9210   unsigned short jresult ;
9211   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9212   uint16_t result;
9213
9214   arg1 = (Dali::Uint16Pair *)jarg1;
9215   {
9216     try {
9217       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9218     } catch (std::out_of_range& e) {
9219       {
9220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9221       };
9222     } catch (std::exception& e) {
9223       {
9224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9225       };
9226     } catch (Dali::DaliException e) {
9227       {
9228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9229       };
9230     } catch (...) {
9231       {
9232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9233       };
9234     }
9235   }
9236
9237   jresult = result;
9238   return jresult;
9239 }
9240
9241
9242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9243   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9244   uint16_t arg2 ;
9245
9246   arg1 = (Dali::Uint16Pair *)jarg1;
9247   arg2 = (uint16_t)jarg2;
9248   {
9249     try {
9250       (arg1)->SetY(arg2);
9251     } catch (std::out_of_range& e) {
9252       {
9253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9254       };
9255     } catch (std::exception& e) {
9256       {
9257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9258       };
9259     } catch (Dali::DaliException e) {
9260       {
9261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9262       };
9263     } catch (...) {
9264       {
9265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9266       };
9267     }
9268   }
9269
9270 }
9271
9272
9273 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9274   unsigned short jresult ;
9275   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9276   uint16_t result;
9277
9278   arg1 = (Dali::Uint16Pair *)jarg1;
9279   {
9280     try {
9281       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9282     } catch (std::out_of_range& e) {
9283       {
9284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9285       };
9286     } catch (std::exception& e) {
9287       {
9288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9289       };
9290     } catch (Dali::DaliException e) {
9291       {
9292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9293       };
9294     } catch (...) {
9295       {
9296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9297       };
9298     }
9299   }
9300
9301   jresult = result;
9302   return jresult;
9303 }
9304
9305
9306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9307   void * jresult ;
9308   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9309   Dali::Uint16Pair *arg2 = 0 ;
9310   Dali::Uint16Pair *result = 0 ;
9311
9312   arg1 = (Dali::Uint16Pair *)jarg1;
9313   arg2 = (Dali::Uint16Pair *)jarg2;
9314   if (!arg2) {
9315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9316     return 0;
9317   }
9318   {
9319     try {
9320       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9321     } catch (std::out_of_range& e) {
9322       {
9323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9324       };
9325     } catch (std::exception& e) {
9326       {
9327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9328       };
9329     } catch (Dali::DaliException e) {
9330       {
9331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9332       };
9333     } catch (...) {
9334       {
9335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9336       };
9337     }
9338   }
9339
9340   jresult = (void *)result;
9341   return jresult;
9342 }
9343
9344
9345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9346   unsigned int jresult ;
9347   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9348   Dali::Uint16Pair *arg2 = 0 ;
9349   bool result;
9350
9351   arg1 = (Dali::Uint16Pair *)jarg1;
9352   arg2 = (Dali::Uint16Pair *)jarg2;
9353   if (!arg2) {
9354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9355     return 0;
9356   }
9357   {
9358     try {
9359       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9360     } catch (std::out_of_range& e) {
9361       {
9362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9363       };
9364     } catch (std::exception& e) {
9365       {
9366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9367       };
9368     } catch (Dali::DaliException e) {
9369       {
9370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9371       };
9372     } catch (...) {
9373       {
9374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9375       };
9376     }
9377   }
9378
9379   jresult = result;
9380   return jresult;
9381 }
9382
9383
9384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9385   unsigned int jresult ;
9386   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9387   Dali::Uint16Pair *arg2 = 0 ;
9388   bool result;
9389
9390   arg1 = (Dali::Uint16Pair *)jarg1;
9391   arg2 = (Dali::Uint16Pair *)jarg2;
9392   if (!arg2) {
9393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9394     return 0;
9395   }
9396   {
9397     try {
9398       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9399     } catch (std::out_of_range& e) {
9400       {
9401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9402       };
9403     } catch (std::exception& e) {
9404       {
9405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9406       };
9407     } catch (Dali::DaliException e) {
9408       {
9409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9410       };
9411     } catch (...) {
9412       {
9413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9414       };
9415     }
9416   }
9417
9418   jresult = result;
9419   return jresult;
9420 }
9421
9422
9423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9424   unsigned int jresult ;
9425   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9426   Dali::Uint16Pair *arg2 = 0 ;
9427   bool result;
9428
9429   arg1 = (Dali::Uint16Pair *)jarg1;
9430   arg2 = (Dali::Uint16Pair *)jarg2;
9431   if (!arg2) {
9432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9433     return 0;
9434   }
9435   {
9436     try {
9437       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9438     } catch (std::out_of_range& e) {
9439       {
9440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9441       };
9442     } catch (std::exception& e) {
9443       {
9444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9445       };
9446     } catch (Dali::DaliException e) {
9447       {
9448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9449       };
9450     } catch (...) {
9451       {
9452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9453       };
9454     }
9455   }
9456
9457   jresult = result;
9458   return jresult;
9459 }
9460
9461
9462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9463   unsigned int jresult ;
9464   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9465   Dali::Uint16Pair *arg2 = 0 ;
9466   bool result;
9467
9468   arg1 = (Dali::Uint16Pair *)jarg1;
9469   arg2 = (Dali::Uint16Pair *)jarg2;
9470   if (!arg2) {
9471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9472     return 0;
9473   }
9474   {
9475     try {
9476       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9477     } catch (std::out_of_range& e) {
9478       {
9479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9480       };
9481     } catch (std::exception& e) {
9482       {
9483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9484       };
9485     } catch (Dali::DaliException e) {
9486       {
9487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9488       };
9489     } catch (...) {
9490       {
9491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9492       };
9493     }
9494   }
9495
9496   jresult = result;
9497   return jresult;
9498 }
9499
9500
9501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9502   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9503
9504   arg1 = (Dali::Uint16Pair *)jarg1;
9505   {
9506     try {
9507       delete arg1;
9508     } catch (std::out_of_range& e) {
9509       {
9510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9511       };
9512     } catch (std::exception& e) {
9513       {
9514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9515       };
9516     } catch (Dali::DaliException e) {
9517       {
9518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9519       };
9520     } catch (...) {
9521       {
9522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9523       };
9524     }
9525   }
9526
9527 }
9528
9529
9530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9531   void * jresult ;
9532   Dali::Degree *result = 0 ;
9533
9534   {
9535     try {
9536       result = (Dali::Degree *)new Dali::Degree();
9537     } catch (std::out_of_range& e) {
9538       {
9539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9540       };
9541     } catch (std::exception& e) {
9542       {
9543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9544       };
9545     } catch (Dali::DaliException e) {
9546       {
9547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9548       };
9549     } catch (...) {
9550       {
9551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9552       };
9553     }
9554   }
9555
9556   jresult = (void *)result;
9557   return jresult;
9558 }
9559
9560
9561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9562   void * jresult ;
9563   float arg1 ;
9564   Dali::Degree *result = 0 ;
9565
9566   arg1 = (float)jarg1;
9567   {
9568     try {
9569       result = (Dali::Degree *)new Dali::Degree(arg1);
9570     } catch (std::out_of_range& e) {
9571       {
9572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9573       };
9574     } catch (std::exception& e) {
9575       {
9576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9577       };
9578     } catch (Dali::DaliException e) {
9579       {
9580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9581       };
9582     } catch (...) {
9583       {
9584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9585       };
9586     }
9587   }
9588
9589   jresult = (void *)result;
9590   return jresult;
9591 }
9592
9593
9594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9595   void * jresult ;
9596   Dali::Radian arg1 ;
9597   Dali::Radian *argp1 ;
9598   Dali::Degree *result = 0 ;
9599
9600   argp1 = (Dali::Radian *)jarg1;
9601   if (!argp1) {
9602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9603     return 0;
9604   }
9605   arg1 = *argp1;
9606   {
9607     try {
9608       result = (Dali::Degree *)new Dali::Degree(arg1);
9609     } catch (std::out_of_range& e) {
9610       {
9611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9612       };
9613     } catch (std::exception& e) {
9614       {
9615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9616       };
9617     } catch (Dali::DaliException e) {
9618       {
9619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9620       };
9621     } catch (...) {
9622       {
9623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9624       };
9625     }
9626   }
9627
9628   jresult = (void *)result;
9629   return jresult;
9630 }
9631
9632
9633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9634   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9635   float arg2 ;
9636
9637   arg1 = (Dali::Degree *)jarg1;
9638   arg2 = (float)jarg2;
9639   if (arg1) (arg1)->degree = arg2;
9640 }
9641
9642
9643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9644   float jresult ;
9645   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9646   float result;
9647
9648   arg1 = (Dali::Degree *)jarg1;
9649   result = (float) ((arg1)->degree);
9650   jresult = result;
9651   return jresult;
9652 }
9653
9654
9655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9656   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9657
9658   arg1 = (Dali::Degree *)jarg1;
9659   {
9660     try {
9661       delete arg1;
9662     } catch (std::out_of_range& e) {
9663       {
9664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9665       };
9666     } catch (std::exception& e) {
9667       {
9668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9669       };
9670     } catch (Dali::DaliException e) {
9671       {
9672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9673       };
9674     } catch (...) {
9675       {
9676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9677       };
9678     }
9679   }
9680
9681 }
9682
9683
9684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9685   void * jresult ;
9686   Dali::Radian *result = 0 ;
9687
9688   result = (Dali::Radian *)&Dali::ANGLE_360;
9689   jresult = (void *)result;
9690   return jresult;
9691 }
9692
9693
9694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9695   void * jresult ;
9696   Dali::Radian *result = 0 ;
9697
9698   result = (Dali::Radian *)&Dali::ANGLE_315;
9699   jresult = (void *)result;
9700   return jresult;
9701 }
9702
9703
9704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9705   void * jresult ;
9706   Dali::Radian *result = 0 ;
9707
9708   result = (Dali::Radian *)&Dali::ANGLE_270;
9709   jresult = (void *)result;
9710   return jresult;
9711 }
9712
9713
9714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9715   void * jresult ;
9716   Dali::Radian *result = 0 ;
9717
9718   result = (Dali::Radian *)&Dali::ANGLE_225;
9719   jresult = (void *)result;
9720   return jresult;
9721 }
9722
9723
9724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9725   void * jresult ;
9726   Dali::Radian *result = 0 ;
9727
9728   result = (Dali::Radian *)&Dali::ANGLE_180;
9729   jresult = (void *)result;
9730   return jresult;
9731 }
9732
9733
9734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9735   void * jresult ;
9736   Dali::Radian *result = 0 ;
9737
9738   result = (Dali::Radian *)&Dali::ANGLE_135;
9739   jresult = (void *)result;
9740   return jresult;
9741 }
9742
9743
9744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9745   void * jresult ;
9746   Dali::Radian *result = 0 ;
9747
9748   result = (Dali::Radian *)&Dali::ANGLE_120;
9749   jresult = (void *)result;
9750   return jresult;
9751 }
9752
9753
9754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9755   void * jresult ;
9756   Dali::Radian *result = 0 ;
9757
9758   result = (Dali::Radian *)&Dali::ANGLE_90;
9759   jresult = (void *)result;
9760   return jresult;
9761 }
9762
9763
9764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9765   void * jresult ;
9766   Dali::Radian *result = 0 ;
9767
9768   result = (Dali::Radian *)&Dali::ANGLE_60;
9769   jresult = (void *)result;
9770   return jresult;
9771 }
9772
9773
9774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9775   void * jresult ;
9776   Dali::Radian *result = 0 ;
9777
9778   result = (Dali::Radian *)&Dali::ANGLE_45;
9779   jresult = (void *)result;
9780   return jresult;
9781 }
9782
9783
9784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9785   void * jresult ;
9786   Dali::Radian *result = 0 ;
9787
9788   result = (Dali::Radian *)&Dali::ANGLE_30;
9789   jresult = (void *)result;
9790   return jresult;
9791 }
9792
9793
9794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9795   void * jresult ;
9796   Dali::Radian *result = 0 ;
9797
9798   result = (Dali::Radian *)&Dali::ANGLE_0;
9799   jresult = (void *)result;
9800   return jresult;
9801 }
9802
9803
9804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9805   unsigned int jresult ;
9806   Dali::Degree *arg1 = 0 ;
9807   Dali::Degree *arg2 = 0 ;
9808   bool result;
9809
9810   arg1 = (Dali::Degree *)jarg1;
9811   if (!arg1) {
9812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9813     return 0;
9814   }
9815   arg2 = (Dali::Degree *)jarg2;
9816   if (!arg2) {
9817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9818     return 0;
9819   }
9820   {
9821     try {
9822       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9823     } catch (std::out_of_range& e) {
9824       {
9825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9826       };
9827     } catch (std::exception& e) {
9828       {
9829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9830       };
9831     } catch (Dali::DaliException e) {
9832       {
9833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9834       };
9835     } catch (...) {
9836       {
9837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9838       };
9839     }
9840   }
9841
9842   jresult = result;
9843   return jresult;
9844 }
9845
9846
9847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9848   unsigned int jresult ;
9849   Dali::Degree *arg1 = 0 ;
9850   Dali::Degree *arg2 = 0 ;
9851   bool result;
9852
9853   arg1 = (Dali::Degree *)jarg1;
9854   if (!arg1) {
9855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9856     return 0;
9857   }
9858   arg2 = (Dali::Degree *)jarg2;
9859   if (!arg2) {
9860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9861     return 0;
9862   }
9863   {
9864     try {
9865       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9866     } catch (std::out_of_range& e) {
9867       {
9868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9869       };
9870     } catch (std::exception& e) {
9871       {
9872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9873       };
9874     } catch (Dali::DaliException e) {
9875       {
9876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9877       };
9878     } catch (...) {
9879       {
9880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9881       };
9882     }
9883   }
9884
9885   jresult = result;
9886   return jresult;
9887 }
9888
9889
9890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9891   void * jresult ;
9892   Dali::Degree arg1 ;
9893   float arg2 ;
9894   float arg3 ;
9895   Dali::Degree *argp1 ;
9896   Dali::Degree result;
9897
9898   argp1 = (Dali::Degree *)jarg1;
9899   if (!argp1) {
9900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9901     return 0;
9902   }
9903   arg1 = *argp1;
9904   arg2 = (float)jarg2;
9905   arg3 = (float)jarg3;
9906   {
9907     try {
9908       result = Dali::Clamp(arg1,arg2,arg3);
9909     } catch (std::out_of_range& e) {
9910       {
9911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9912       };
9913     } catch (std::exception& e) {
9914       {
9915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9916       };
9917     } catch (Dali::DaliException e) {
9918       {
9919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9920       };
9921     } catch (...) {
9922       {
9923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9924       };
9925     }
9926   }
9927
9928   jresult = new Dali::Degree((const Dali::Degree &)result);
9929   return jresult;
9930 }
9931
9932
9933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9934   void * jresult ;
9935   Dali::Radian *result = 0 ;
9936
9937   {
9938     try {
9939       result = (Dali::Radian *)new Dali::Radian();
9940     } catch (std::out_of_range& e) {
9941       {
9942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9943       };
9944     } catch (std::exception& e) {
9945       {
9946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9947       };
9948     } catch (Dali::DaliException e) {
9949       {
9950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9951       };
9952     } catch (...) {
9953       {
9954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9955       };
9956     }
9957   }
9958
9959   jresult = (void *)result;
9960   return jresult;
9961 }
9962
9963
9964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9965   void * jresult ;
9966   float arg1 ;
9967   Dali::Radian *result = 0 ;
9968
9969   arg1 = (float)jarg1;
9970   {
9971     try {
9972       result = (Dali::Radian *)new Dali::Radian(arg1);
9973     } catch (std::out_of_range& e) {
9974       {
9975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9976       };
9977     } catch (std::exception& e) {
9978       {
9979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9980       };
9981     } catch (Dali::DaliException e) {
9982       {
9983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9984       };
9985     } catch (...) {
9986       {
9987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9988       };
9989     }
9990   }
9991
9992   jresult = (void *)result;
9993   return jresult;
9994 }
9995
9996
9997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9998   void * jresult ;
9999   Dali::Degree arg1 ;
10000   Dali::Degree *argp1 ;
10001   Dali::Radian *result = 0 ;
10002
10003   argp1 = (Dali::Degree *)jarg1;
10004   if (!argp1) {
10005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10006     return 0;
10007   }
10008   arg1 = *argp1;
10009   {
10010     try {
10011       result = (Dali::Radian *)new Dali::Radian(arg1);
10012     } catch (std::out_of_range& e) {
10013       {
10014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10015       };
10016     } catch (std::exception& e) {
10017       {
10018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10019       };
10020     } catch (Dali::DaliException e) {
10021       {
10022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10023       };
10024     } catch (...) {
10025       {
10026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10027       };
10028     }
10029   }
10030
10031   jresult = (void *)result;
10032   return jresult;
10033 }
10034
10035
10036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10037   void * jresult ;
10038   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10039   float arg2 ;
10040   Dali::Radian *result = 0 ;
10041
10042   arg1 = (Dali::Radian *)jarg1;
10043   arg2 = (float)jarg2;
10044   {
10045     try {
10046       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10047     } catch (std::out_of_range& e) {
10048       {
10049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10050       };
10051     } catch (std::exception& e) {
10052       {
10053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10054       };
10055     } catch (Dali::DaliException e) {
10056       {
10057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10058       };
10059     } catch (...) {
10060       {
10061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10062       };
10063     }
10064   }
10065
10066   jresult = (void *)result;
10067   return jresult;
10068 }
10069
10070
10071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10072   void * jresult ;
10073   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10074   Dali::Degree arg2 ;
10075   Dali::Degree *argp2 ;
10076   Dali::Radian *result = 0 ;
10077
10078   arg1 = (Dali::Radian *)jarg1;
10079   argp2 = (Dali::Degree *)jarg2;
10080   if (!argp2) {
10081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10082     return 0;
10083   }
10084   arg2 = *argp2;
10085   {
10086     try {
10087       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10088     } catch (std::out_of_range& e) {
10089       {
10090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10091       };
10092     } catch (std::exception& e) {
10093       {
10094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10095       };
10096     } catch (Dali::DaliException e) {
10097       {
10098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10099       };
10100     } catch (...) {
10101       {
10102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10103       };
10104     }
10105   }
10106
10107   jresult = (void *)result;
10108   return jresult;
10109 }
10110
10111
10112 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10113   float jresult ;
10114   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10115   float result;
10116
10117   arg1 = (Dali::Radian *)jarg1;
10118   {
10119     try {
10120       result = (float)((Dali::Radian const *)arg1)->operator float();
10121     } catch (std::out_of_range& e) {
10122       {
10123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10124       };
10125     } catch (std::exception& e) {
10126       {
10127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10128       };
10129     } catch (Dali::DaliException e) {
10130       {
10131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10132       };
10133     } catch (...) {
10134       {
10135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10136       };
10137     }
10138   }
10139
10140   jresult = result;
10141   return jresult;
10142 }
10143
10144
10145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10146   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10147   float arg2 ;
10148
10149   arg1 = (Dali::Radian *)jarg1;
10150   arg2 = (float)jarg2;
10151   if (arg1) (arg1)->radian = arg2;
10152 }
10153
10154
10155 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10156   float jresult ;
10157   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10158   float result;
10159
10160   arg1 = (Dali::Radian *)jarg1;
10161   result = (float) ((arg1)->radian);
10162   jresult = result;
10163   return jresult;
10164 }
10165
10166
10167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10168   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10169
10170   arg1 = (Dali::Radian *)jarg1;
10171   {
10172     try {
10173       delete arg1;
10174     } catch (std::out_of_range& e) {
10175       {
10176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10177       };
10178     } catch (std::exception& e) {
10179       {
10180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10181       };
10182     } catch (Dali::DaliException e) {
10183       {
10184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10185       };
10186     } catch (...) {
10187       {
10188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10189       };
10190     }
10191   }
10192
10193 }
10194
10195
10196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10197   unsigned int jresult ;
10198   Dali::Radian arg1 ;
10199   Dali::Radian arg2 ;
10200   Dali::Radian *argp1 ;
10201   Dali::Radian *argp2 ;
10202   bool result;
10203
10204   argp1 = (Dali::Radian *)jarg1;
10205   if (!argp1) {
10206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10207     return 0;
10208   }
10209   arg1 = *argp1;
10210   argp2 = (Dali::Radian *)jarg2;
10211   if (!argp2) {
10212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10213     return 0;
10214   }
10215   arg2 = *argp2;
10216   {
10217     try {
10218       result = (bool)Dali::operator ==(arg1,arg2);
10219     } catch (std::out_of_range& e) {
10220       {
10221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10222       };
10223     } catch (std::exception& e) {
10224       {
10225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10226       };
10227     } catch (Dali::DaliException e) {
10228       {
10229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10230       };
10231     } catch (...) {
10232       {
10233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10234       };
10235     }
10236   }
10237
10238   jresult = result;
10239   return jresult;
10240 }
10241
10242
10243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10244   unsigned int jresult ;
10245   Dali::Radian arg1 ;
10246   Dali::Radian arg2 ;
10247   Dali::Radian *argp1 ;
10248   Dali::Radian *argp2 ;
10249   bool result;
10250
10251   argp1 = (Dali::Radian *)jarg1;
10252   if (!argp1) {
10253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10254     return 0;
10255   }
10256   arg1 = *argp1;
10257   argp2 = (Dali::Radian *)jarg2;
10258   if (!argp2) {
10259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10260     return 0;
10261   }
10262   arg2 = *argp2;
10263   {
10264     try {
10265       result = (bool)Dali::operator !=(arg1,arg2);
10266     } catch (std::out_of_range& e) {
10267       {
10268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10269       };
10270     } catch (std::exception& e) {
10271       {
10272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10273       };
10274     } catch (Dali::DaliException e) {
10275       {
10276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10277       };
10278     } catch (...) {
10279       {
10280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10281       };
10282     }
10283   }
10284
10285   jresult = result;
10286   return jresult;
10287 }
10288
10289
10290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10291   unsigned int jresult ;
10292   Dali::Radian arg1 ;
10293   Dali::Degree arg2 ;
10294   Dali::Radian *argp1 ;
10295   Dali::Degree *argp2 ;
10296   bool result;
10297
10298   argp1 = (Dali::Radian *)jarg1;
10299   if (!argp1) {
10300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10301     return 0;
10302   }
10303   arg1 = *argp1;
10304   argp2 = (Dali::Degree *)jarg2;
10305   if (!argp2) {
10306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10307     return 0;
10308   }
10309   arg2 = *argp2;
10310   {
10311     try {
10312       result = (bool)Dali::operator ==(arg1,arg2);
10313     } catch (std::out_of_range& e) {
10314       {
10315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10316       };
10317     } catch (std::exception& e) {
10318       {
10319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10320       };
10321     } catch (Dali::DaliException e) {
10322       {
10323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10324       };
10325     } catch (...) {
10326       {
10327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10328       };
10329     }
10330   }
10331
10332   jresult = result;
10333   return jresult;
10334 }
10335
10336
10337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10338   unsigned int jresult ;
10339   Dali::Radian arg1 ;
10340   Dali::Degree arg2 ;
10341   Dali::Radian *argp1 ;
10342   Dali::Degree *argp2 ;
10343   bool result;
10344
10345   argp1 = (Dali::Radian *)jarg1;
10346   if (!argp1) {
10347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10348     return 0;
10349   }
10350   arg1 = *argp1;
10351   argp2 = (Dali::Degree *)jarg2;
10352   if (!argp2) {
10353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10354     return 0;
10355   }
10356   arg2 = *argp2;
10357   {
10358     try {
10359       result = (bool)Dali::operator !=(arg1,arg2);
10360     } catch (std::out_of_range& e) {
10361       {
10362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10363       };
10364     } catch (std::exception& e) {
10365       {
10366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10367       };
10368     } catch (Dali::DaliException e) {
10369       {
10370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10371       };
10372     } catch (...) {
10373       {
10374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10375       };
10376     }
10377   }
10378
10379   jresult = result;
10380   return jresult;
10381 }
10382
10383
10384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10385   unsigned int jresult ;
10386   Dali::Degree arg1 ;
10387   Dali::Radian arg2 ;
10388   Dali::Degree *argp1 ;
10389   Dali::Radian *argp2 ;
10390   bool result;
10391
10392   argp1 = (Dali::Degree *)jarg1;
10393   if (!argp1) {
10394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10395     return 0;
10396   }
10397   arg1 = *argp1;
10398   argp2 = (Dali::Radian *)jarg2;
10399   if (!argp2) {
10400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10401     return 0;
10402   }
10403   arg2 = *argp2;
10404   {
10405     try {
10406       result = (bool)Dali::operator ==(arg1,arg2);
10407     } catch (std::out_of_range& e) {
10408       {
10409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10410       };
10411     } catch (std::exception& e) {
10412       {
10413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10414       };
10415     } catch (Dali::DaliException e) {
10416       {
10417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10418       };
10419     } catch (...) {
10420       {
10421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10422       };
10423     }
10424   }
10425
10426   jresult = result;
10427   return jresult;
10428 }
10429
10430
10431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10432   unsigned int jresult ;
10433   Dali::Degree arg1 ;
10434   Dali::Radian arg2 ;
10435   Dali::Degree *argp1 ;
10436   Dali::Radian *argp2 ;
10437   bool result;
10438
10439   argp1 = (Dali::Degree *)jarg1;
10440   if (!argp1) {
10441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10442     return 0;
10443   }
10444   arg1 = *argp1;
10445   argp2 = (Dali::Radian *)jarg2;
10446   if (!argp2) {
10447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10448     return 0;
10449   }
10450   arg2 = *argp2;
10451   {
10452     try {
10453       result = (bool)Dali::operator !=(arg1,arg2);
10454     } catch (std::out_of_range& e) {
10455       {
10456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10457       };
10458     } catch (std::exception& e) {
10459       {
10460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10461       };
10462     } catch (Dali::DaliException e) {
10463       {
10464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10465       };
10466     } catch (...) {
10467       {
10468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10469       };
10470     }
10471   }
10472
10473   jresult = result;
10474   return jresult;
10475 }
10476
10477
10478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10479   unsigned int jresult ;
10480   Dali::Radian arg1 ;
10481   Dali::Radian arg2 ;
10482   Dali::Radian *argp1 ;
10483   Dali::Radian *argp2 ;
10484   bool result;
10485
10486   argp1 = (Dali::Radian *)jarg1;
10487   if (!argp1) {
10488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10489     return 0;
10490   }
10491   arg1 = *argp1;
10492   argp2 = (Dali::Radian *)jarg2;
10493   if (!argp2) {
10494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10495     return 0;
10496   }
10497   arg2 = *argp2;
10498   {
10499     try {
10500       result = (bool)Dali::operator >(arg1,arg2);
10501     } catch (std::out_of_range& e) {
10502       {
10503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10504       };
10505     } catch (std::exception& e) {
10506       {
10507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10508       };
10509     } catch (Dali::DaliException e) {
10510       {
10511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10512       };
10513     } catch (...) {
10514       {
10515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10516       };
10517     }
10518   }
10519
10520   jresult = result;
10521   return jresult;
10522 }
10523
10524
10525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10526   unsigned int jresult ;
10527   Dali::Radian arg1 ;
10528   Dali::Degree arg2 ;
10529   Dali::Radian *argp1 ;
10530   Dali::Degree *argp2 ;
10531   bool result;
10532
10533   argp1 = (Dali::Radian *)jarg1;
10534   if (!argp1) {
10535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10536     return 0;
10537   }
10538   arg1 = *argp1;
10539   argp2 = (Dali::Degree *)jarg2;
10540   if (!argp2) {
10541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10542     return 0;
10543   }
10544   arg2 = *argp2;
10545   {
10546     try {
10547       result = (bool)Dali::operator >(arg1,arg2);
10548     } catch (std::out_of_range& e) {
10549       {
10550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10551       };
10552     } catch (std::exception& e) {
10553       {
10554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10555       };
10556     } catch (Dali::DaliException e) {
10557       {
10558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10559       };
10560     } catch (...) {
10561       {
10562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10563       };
10564     }
10565   }
10566
10567   jresult = result;
10568   return jresult;
10569 }
10570
10571
10572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10573   unsigned int jresult ;
10574   Dali::Degree arg1 ;
10575   Dali::Radian arg2 ;
10576   Dali::Degree *argp1 ;
10577   Dali::Radian *argp2 ;
10578   bool result;
10579
10580   argp1 = (Dali::Degree *)jarg1;
10581   if (!argp1) {
10582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10583     return 0;
10584   }
10585   arg1 = *argp1;
10586   argp2 = (Dali::Radian *)jarg2;
10587   if (!argp2) {
10588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10589     return 0;
10590   }
10591   arg2 = *argp2;
10592   {
10593     try {
10594       result = (bool)Dali::operator >(arg1,arg2);
10595     } catch (std::out_of_range& e) {
10596       {
10597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10598       };
10599     } catch (std::exception& e) {
10600       {
10601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10602       };
10603     } catch (Dali::DaliException e) {
10604       {
10605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10606       };
10607     } catch (...) {
10608       {
10609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10610       };
10611     }
10612   }
10613
10614   jresult = result;
10615   return jresult;
10616 }
10617
10618
10619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10620   unsigned int jresult ;
10621   Dali::Radian arg1 ;
10622   Dali::Radian arg2 ;
10623   Dali::Radian *argp1 ;
10624   Dali::Radian *argp2 ;
10625   bool result;
10626
10627   argp1 = (Dali::Radian *)jarg1;
10628   if (!argp1) {
10629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10630     return 0;
10631   }
10632   arg1 = *argp1;
10633   argp2 = (Dali::Radian *)jarg2;
10634   if (!argp2) {
10635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10636     return 0;
10637   }
10638   arg2 = *argp2;
10639   {
10640     try {
10641       result = (bool)Dali::operator <(arg1,arg2);
10642     } catch (std::out_of_range& e) {
10643       {
10644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10645       };
10646     } catch (std::exception& e) {
10647       {
10648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10649       };
10650     } catch (Dali::DaliException e) {
10651       {
10652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10653       };
10654     } catch (...) {
10655       {
10656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10657       };
10658     }
10659   }
10660
10661   jresult = result;
10662   return jresult;
10663 }
10664
10665
10666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10667   unsigned int jresult ;
10668   Dali::Radian arg1 ;
10669   Dali::Degree arg2 ;
10670   Dali::Radian *argp1 ;
10671   Dali::Degree *argp2 ;
10672   bool result;
10673
10674   argp1 = (Dali::Radian *)jarg1;
10675   if (!argp1) {
10676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10677     return 0;
10678   }
10679   arg1 = *argp1;
10680   argp2 = (Dali::Degree *)jarg2;
10681   if (!argp2) {
10682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10683     return 0;
10684   }
10685   arg2 = *argp2;
10686   {
10687     try {
10688       result = (bool)Dali::operator <(arg1,arg2);
10689     } catch (std::out_of_range& e) {
10690       {
10691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10692       };
10693     } catch (std::exception& e) {
10694       {
10695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10696       };
10697     } catch (Dali::DaliException e) {
10698       {
10699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10700       };
10701     } catch (...) {
10702       {
10703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10704       };
10705     }
10706   }
10707
10708   jresult = result;
10709   return jresult;
10710 }
10711
10712
10713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10714   unsigned int jresult ;
10715   Dali::Degree arg1 ;
10716   Dali::Radian arg2 ;
10717   Dali::Degree *argp1 ;
10718   Dali::Radian *argp2 ;
10719   bool result;
10720
10721   argp1 = (Dali::Degree *)jarg1;
10722   if (!argp1) {
10723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10724     return 0;
10725   }
10726   arg1 = *argp1;
10727   argp2 = (Dali::Radian *)jarg2;
10728   if (!argp2) {
10729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10730     return 0;
10731   }
10732   arg2 = *argp2;
10733   {
10734     try {
10735       result = (bool)Dali::operator <(arg1,arg2);
10736     } catch (std::out_of_range& e) {
10737       {
10738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10739       };
10740     } catch (std::exception& e) {
10741       {
10742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10743       };
10744     } catch (Dali::DaliException e) {
10745       {
10746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10747       };
10748     } catch (...) {
10749       {
10750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10751       };
10752     }
10753   }
10754
10755   jresult = result;
10756   return jresult;
10757 }
10758
10759
10760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10761   void * jresult ;
10762   Dali::Radian arg1 ;
10763   float arg2 ;
10764   Dali::Radian *argp1 ;
10765   Dali::Radian result;
10766
10767   argp1 = (Dali::Radian *)jarg1;
10768   if (!argp1) {
10769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10770     return 0;
10771   }
10772   arg1 = *argp1;
10773   arg2 = (float)jarg2;
10774   {
10775     try {
10776       result = Dali::operator *(arg1,arg2);
10777     } catch (std::out_of_range& e) {
10778       {
10779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10780       };
10781     } catch (std::exception& e) {
10782       {
10783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10784       };
10785     } catch (Dali::DaliException e) {
10786       {
10787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10788       };
10789     } catch (...) {
10790       {
10791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10792       };
10793     }
10794   }
10795
10796   jresult = new Dali::Radian((const Dali::Radian &)result);
10797   return jresult;
10798 }
10799
10800
10801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10802   void * jresult ;
10803   Dali::Radian arg1 ;
10804   Dali::Radian *argp1 ;
10805   Dali::Radian result;
10806
10807   argp1 = (Dali::Radian *)jarg1;
10808   if (!argp1) {
10809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10810     return 0;
10811   }
10812   arg1 = *argp1;
10813   {
10814     try {
10815       result = Dali::operator -(arg1);
10816     } catch (std::out_of_range& e) {
10817       {
10818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10819       };
10820     } catch (std::exception& e) {
10821       {
10822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10823       };
10824     } catch (Dali::DaliException e) {
10825       {
10826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10827       };
10828     } catch (...) {
10829       {
10830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10831       };
10832     }
10833   }
10834
10835   jresult = new Dali::Radian((const Dali::Radian &)result);
10836   return jresult;
10837 }
10838
10839
10840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10841   void * jresult ;
10842   Dali::Radian arg1 ;
10843   float arg2 ;
10844   float arg3 ;
10845   Dali::Radian *argp1 ;
10846   Dali::Radian result;
10847
10848   argp1 = (Dali::Radian *)jarg1;
10849   if (!argp1) {
10850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10851     return 0;
10852   }
10853   arg1 = *argp1;
10854   arg2 = (float)jarg2;
10855   arg3 = (float)jarg3;
10856   {
10857     try {
10858       result = Dali::Clamp(arg1,arg2,arg3);
10859     } catch (std::out_of_range& e) {
10860       {
10861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10862       };
10863     } catch (std::exception& e) {
10864       {
10865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10866       };
10867     } catch (Dali::DaliException e) {
10868       {
10869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10870       };
10871     } catch (...) {
10872       {
10873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10874       };
10875     }
10876   }
10877
10878   jresult = new Dali::Radian((const Dali::Radian &)result);
10879   return jresult;
10880 }
10881
10882
10883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10884   void * jresult ;
10885   Dali::Quaternion *result = 0 ;
10886
10887   {
10888     try {
10889       result = (Dali::Quaternion *)new Dali::Quaternion();
10890     } catch (std::out_of_range& e) {
10891       {
10892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10893       };
10894     } catch (std::exception& e) {
10895       {
10896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10897       };
10898     } catch (Dali::DaliException e) {
10899       {
10900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10901       };
10902     } catch (...) {
10903       {
10904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10905       };
10906     }
10907   }
10908
10909   jresult = (void *)result;
10910   return jresult;
10911 }
10912
10913
10914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10915   void * jresult ;
10916   Dali::Radian arg1 ;
10917   Dali::Vector3 *arg2 = 0 ;
10918   Dali::Radian *argp1 ;
10919   Dali::Quaternion *result = 0 ;
10920
10921   argp1 = (Dali::Radian *)jarg1;
10922   if (!argp1) {
10923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10924     return 0;
10925   }
10926   arg1 = *argp1;
10927   arg2 = (Dali::Vector3 *)jarg2;
10928   if (!arg2) {
10929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10930     return 0;
10931   }
10932   {
10933     try {
10934       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10935     } catch (std::out_of_range& e) {
10936       {
10937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10938       };
10939     } catch (std::exception& e) {
10940       {
10941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10942       };
10943     } catch (Dali::DaliException e) {
10944       {
10945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10946       };
10947     } catch (...) {
10948       {
10949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10950       };
10951     }
10952   }
10953
10954   jresult = (void *)result;
10955   return jresult;
10956 }
10957
10958
10959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10960   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10961
10962   arg1 = (Dali::Quaternion *)jarg1;
10963   {
10964     try {
10965       delete arg1;
10966     } catch (std::out_of_range& e) {
10967       {
10968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10969       };
10970     } catch (std::exception& e) {
10971       {
10972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10973       };
10974     } catch (Dali::DaliException e) {
10975       {
10976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10977       };
10978     } catch (...) {
10979       {
10980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10981       };
10982     }
10983   }
10984
10985 }
10986
10987
10988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10989   void * jresult ;
10990   Dali::Quaternion *result = 0 ;
10991
10992   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10993   jresult = (void *)result;
10994   return jresult;
10995 }
10996
10997
10998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10999   unsigned int jresult ;
11000   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11001   bool result;
11002
11003   arg1 = (Dali::Quaternion *)jarg1;
11004   {
11005     try {
11006       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11007     } catch (std::out_of_range& e) {
11008       {
11009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11010       };
11011     } catch (std::exception& e) {
11012       {
11013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11014       };
11015     } catch (Dali::DaliException e) {
11016       {
11017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11018       };
11019     } catch (...) {
11020       {
11021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11022       };
11023     }
11024   }
11025
11026   jresult = result;
11027   return jresult;
11028 }
11029
11030
11031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11032   unsigned int jresult ;
11033   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11034   Dali::Vector3 *arg2 = 0 ;
11035   Dali::Radian *arg3 = 0 ;
11036   bool result;
11037
11038   arg1 = (Dali::Quaternion *)jarg1;
11039   arg2 = (Dali::Vector3 *)jarg2;
11040   if (!arg2) {
11041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11042     return 0;
11043   }
11044   arg3 = (Dali::Radian *)jarg3;
11045   if (!arg3) {
11046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11047     return 0;
11048   }
11049   {
11050     try {
11051       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11052     } catch (std::out_of_range& e) {
11053       {
11054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11055       };
11056     } catch (std::exception& e) {
11057       {
11058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11059       };
11060     } catch (Dali::DaliException e) {
11061       {
11062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11063       };
11064     } catch (...) {
11065       {
11066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11067       };
11068     }
11069   }
11070
11071   jresult = result;
11072   return jresult;
11073 }
11074
11075
11076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11077   void * jresult ;
11078   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11079   Dali::Quaternion *arg2 = 0 ;
11080   Dali::Quaternion result;
11081
11082   arg1 = (Dali::Quaternion *)jarg1;
11083   arg2 = (Dali::Quaternion *)jarg2;
11084   if (!arg2) {
11085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11086     return 0;
11087   }
11088   {
11089     try {
11090       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11091     } catch (std::out_of_range& e) {
11092       {
11093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11094       };
11095     } catch (std::exception& e) {
11096       {
11097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11098       };
11099     } catch (Dali::DaliException e) {
11100       {
11101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11102       };
11103     } catch (...) {
11104       {
11105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11106       };
11107     }
11108   }
11109
11110   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11111   return jresult;
11112 }
11113
11114
11115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11116   void * jresult ;
11117   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11118   Dali::Quaternion *arg2 = 0 ;
11119   Dali::Quaternion result;
11120
11121   arg1 = (Dali::Quaternion *)jarg1;
11122   arg2 = (Dali::Quaternion *)jarg2;
11123   if (!arg2) {
11124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11125     return 0;
11126   }
11127   {
11128     try {
11129       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11130     } catch (std::out_of_range& e) {
11131       {
11132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11133       };
11134     } catch (std::exception& e) {
11135       {
11136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11137       };
11138     } catch (Dali::DaliException e) {
11139       {
11140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11141       };
11142     } catch (...) {
11143       {
11144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11145       };
11146     }
11147   }
11148
11149   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11150   return jresult;
11151 }
11152
11153
11154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11155   void * jresult ;
11156   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11157   Dali::Quaternion *arg2 = 0 ;
11158   Dali::Quaternion result;
11159
11160   arg1 = (Dali::Quaternion *)jarg1;
11161   arg2 = (Dali::Quaternion *)jarg2;
11162   if (!arg2) {
11163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11164     return 0;
11165   }
11166   {
11167     try {
11168       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11169     } catch (std::out_of_range& e) {
11170       {
11171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11172       };
11173     } catch (std::exception& e) {
11174       {
11175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11176       };
11177     } catch (Dali::DaliException e) {
11178       {
11179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11180       };
11181     } catch (...) {
11182       {
11183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11184       };
11185     }
11186   }
11187
11188   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11189   return jresult;
11190 }
11191
11192
11193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11194   void * jresult ;
11195   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11196   Dali::Vector3 *arg2 = 0 ;
11197   Dali::Vector3 result;
11198
11199   arg1 = (Dali::Quaternion *)jarg1;
11200   arg2 = (Dali::Vector3 *)jarg2;
11201   if (!arg2) {
11202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11203     return 0;
11204   }
11205   {
11206     try {
11207       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11208     } catch (std::out_of_range& e) {
11209       {
11210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11211       };
11212     } catch (std::exception& e) {
11213       {
11214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11215       };
11216     } catch (Dali::DaliException e) {
11217       {
11218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11219       };
11220     } catch (...) {
11221       {
11222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11223       };
11224     }
11225   }
11226
11227   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11228   return jresult;
11229 }
11230
11231
11232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11233   void * jresult ;
11234   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11235   Dali::Quaternion *arg2 = 0 ;
11236   Dali::Quaternion result;
11237
11238   arg1 = (Dali::Quaternion *)jarg1;
11239   arg2 = (Dali::Quaternion *)jarg2;
11240   if (!arg2) {
11241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11242     return 0;
11243   }
11244   {
11245     try {
11246       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11247     } catch (std::out_of_range& e) {
11248       {
11249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11250       };
11251     } catch (std::exception& e) {
11252       {
11253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11254       };
11255     } catch (Dali::DaliException e) {
11256       {
11257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11258       };
11259     } catch (...) {
11260       {
11261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11262       };
11263     }
11264   }
11265
11266   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11267   return jresult;
11268 }
11269
11270
11271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11272   void * jresult ;
11273   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11274   float arg2 ;
11275   Dali::Quaternion result;
11276
11277   arg1 = (Dali::Quaternion *)jarg1;
11278   arg2 = (float)jarg2;
11279   {
11280     try {
11281       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11282     } catch (std::out_of_range& e) {
11283       {
11284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11285       };
11286     } catch (std::exception& e) {
11287       {
11288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11289       };
11290     } catch (Dali::DaliException e) {
11291       {
11292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11293       };
11294     } catch (...) {
11295       {
11296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11297       };
11298     }
11299   }
11300
11301   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11302   return jresult;
11303 }
11304
11305
11306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11307   void * jresult ;
11308   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11309   float arg2 ;
11310   Dali::Quaternion result;
11311
11312   arg1 = (Dali::Quaternion *)jarg1;
11313   arg2 = (float)jarg2;
11314   {
11315     try {
11316       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11317     } catch (std::out_of_range& e) {
11318       {
11319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11320       };
11321     } catch (std::exception& e) {
11322       {
11323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11324       };
11325     } catch (Dali::DaliException e) {
11326       {
11327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11328       };
11329     } catch (...) {
11330       {
11331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11332       };
11333     }
11334   }
11335
11336   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11337   return jresult;
11338 }
11339
11340
11341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11342   void * jresult ;
11343   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11344   Dali::Quaternion result;
11345
11346   arg1 = (Dali::Quaternion *)jarg1;
11347   {
11348     try {
11349       result = ((Dali::Quaternion const *)arg1)->operator -();
11350     } catch (std::out_of_range& e) {
11351       {
11352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11353       };
11354     } catch (std::exception& e) {
11355       {
11356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11357       };
11358     } catch (Dali::DaliException e) {
11359       {
11360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11361       };
11362     } catch (...) {
11363       {
11364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11365       };
11366     }
11367   }
11368
11369   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11370   return jresult;
11371 }
11372
11373
11374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11375   void * jresult ;
11376   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11377   Dali::Quaternion *arg2 = 0 ;
11378   Dali::Quaternion *result = 0 ;
11379
11380   arg1 = (Dali::Quaternion *)jarg1;
11381   arg2 = (Dali::Quaternion *)jarg2;
11382   if (!arg2) {
11383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11384     return 0;
11385   }
11386   {
11387     try {
11388       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11389     } catch (std::out_of_range& e) {
11390       {
11391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11392       };
11393     } catch (std::exception& e) {
11394       {
11395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11396       };
11397     } catch (Dali::DaliException e) {
11398       {
11399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11400       };
11401     } catch (...) {
11402       {
11403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11404       };
11405     }
11406   }
11407
11408   jresult = (void *)result;
11409   return jresult;
11410 }
11411
11412
11413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11414   void * jresult ;
11415   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11416   Dali::Quaternion *arg2 = 0 ;
11417   Dali::Quaternion *result = 0 ;
11418
11419   arg1 = (Dali::Quaternion *)jarg1;
11420   arg2 = (Dali::Quaternion *)jarg2;
11421   if (!arg2) {
11422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11423     return 0;
11424   }
11425   {
11426     try {
11427       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11428     } catch (std::out_of_range& e) {
11429       {
11430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11431       };
11432     } catch (std::exception& e) {
11433       {
11434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11435       };
11436     } catch (Dali::DaliException e) {
11437       {
11438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11439       };
11440     } catch (...) {
11441       {
11442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11443       };
11444     }
11445   }
11446
11447   jresult = (void *)result;
11448   return jresult;
11449 }
11450
11451
11452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11453   void * jresult ;
11454   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11455   Dali::Quaternion *arg2 = 0 ;
11456   Dali::Quaternion *result = 0 ;
11457
11458   arg1 = (Dali::Quaternion *)jarg1;
11459   arg2 = (Dali::Quaternion *)jarg2;
11460   if (!arg2) {
11461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11462     return 0;
11463   }
11464   {
11465     try {
11466       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11467     } catch (std::out_of_range& e) {
11468       {
11469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11470       };
11471     } catch (std::exception& e) {
11472       {
11473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11474       };
11475     } catch (Dali::DaliException e) {
11476       {
11477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11478       };
11479     } catch (...) {
11480       {
11481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11482       };
11483     }
11484   }
11485
11486   jresult = (void *)result;
11487   return jresult;
11488 }
11489
11490
11491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11492   void * jresult ;
11493   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11494   float arg2 ;
11495   Dali::Quaternion *result = 0 ;
11496
11497   arg1 = (Dali::Quaternion *)jarg1;
11498   arg2 = (float)jarg2;
11499   {
11500     try {
11501       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11502     } catch (std::out_of_range& e) {
11503       {
11504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11505       };
11506     } catch (std::exception& e) {
11507       {
11508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11509       };
11510     } catch (Dali::DaliException e) {
11511       {
11512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11513       };
11514     } catch (...) {
11515       {
11516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11517       };
11518     }
11519   }
11520
11521   jresult = (void *)result;
11522   return jresult;
11523 }
11524
11525
11526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11527   void * jresult ;
11528   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11529   float arg2 ;
11530   Dali::Quaternion *result = 0 ;
11531
11532   arg1 = (Dali::Quaternion *)jarg1;
11533   arg2 = (float)jarg2;
11534   {
11535     try {
11536       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11537     } catch (std::out_of_range& e) {
11538       {
11539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11540       };
11541     } catch (std::exception& e) {
11542       {
11543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11544       };
11545     } catch (Dali::DaliException e) {
11546       {
11547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11548       };
11549     } catch (...) {
11550       {
11551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11552       };
11553     }
11554   }
11555
11556   jresult = (void *)result;
11557   return jresult;
11558 }
11559
11560
11561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11562   unsigned int jresult ;
11563   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11564   Dali::Quaternion *arg2 = 0 ;
11565   bool result;
11566
11567   arg1 = (Dali::Quaternion *)jarg1;
11568   arg2 = (Dali::Quaternion *)jarg2;
11569   if (!arg2) {
11570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11571     return 0;
11572   }
11573   {
11574     try {
11575       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11576     } catch (std::out_of_range& e) {
11577       {
11578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11579       };
11580     } catch (std::exception& e) {
11581       {
11582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11583       };
11584     } catch (Dali::DaliException e) {
11585       {
11586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11587       };
11588     } catch (...) {
11589       {
11590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11591       };
11592     }
11593   }
11594
11595   jresult = result;
11596   return jresult;
11597 }
11598
11599
11600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11601   unsigned int jresult ;
11602   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11603   Dali::Quaternion *arg2 = 0 ;
11604   bool result;
11605
11606   arg1 = (Dali::Quaternion *)jarg1;
11607   arg2 = (Dali::Quaternion *)jarg2;
11608   if (!arg2) {
11609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11610     return 0;
11611   }
11612   {
11613     try {
11614       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11615     } catch (std::out_of_range& e) {
11616       {
11617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11618       };
11619     } catch (std::exception& e) {
11620       {
11621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11622       };
11623     } catch (Dali::DaliException e) {
11624       {
11625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11626       };
11627     } catch (...) {
11628       {
11629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11630       };
11631     }
11632   }
11633
11634   jresult = result;
11635   return jresult;
11636 }
11637
11638
11639 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11640   float jresult ;
11641   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11642   float result;
11643
11644   arg1 = (Dali::Quaternion *)jarg1;
11645   {
11646     try {
11647       result = (float)((Dali::Quaternion const *)arg1)->Length();
11648     } catch (std::out_of_range& e) {
11649       {
11650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11651       };
11652     } catch (std::exception& e) {
11653       {
11654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11655       };
11656     } catch (Dali::DaliException e) {
11657       {
11658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11659       };
11660     } catch (...) {
11661       {
11662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11663       };
11664     }
11665   }
11666
11667   jresult = result;
11668   return jresult;
11669 }
11670
11671
11672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11673   float jresult ;
11674   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11675   float result;
11676
11677   arg1 = (Dali::Quaternion *)jarg1;
11678   {
11679     try {
11680       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11681     } catch (std::out_of_range& e) {
11682       {
11683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11684       };
11685     } catch (std::exception& e) {
11686       {
11687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11688       };
11689     } catch (Dali::DaliException e) {
11690       {
11691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11692       };
11693     } catch (...) {
11694       {
11695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11696       };
11697     }
11698   }
11699
11700   jresult = result;
11701   return jresult;
11702 }
11703
11704
11705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11706   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11707
11708   arg1 = (Dali::Quaternion *)jarg1;
11709   {
11710     try {
11711       (arg1)->Normalize();
11712     } catch (std::out_of_range& e) {
11713       {
11714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11715       };
11716     } catch (std::exception& e) {
11717       {
11718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11719       };
11720     } catch (Dali::DaliException e) {
11721       {
11722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11723       };
11724     } catch (...) {
11725       {
11726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11727       };
11728     }
11729   }
11730
11731 }
11732
11733
11734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11735   void * jresult ;
11736   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11737   Dali::Quaternion result;
11738
11739   arg1 = (Dali::Quaternion *)jarg1;
11740   {
11741     try {
11742       result = ((Dali::Quaternion const *)arg1)->Normalized();
11743     } catch (std::out_of_range& e) {
11744       {
11745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11746       };
11747     } catch (std::exception& e) {
11748       {
11749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11750       };
11751     } catch (Dali::DaliException e) {
11752       {
11753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11754       };
11755     } catch (...) {
11756       {
11757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11758       };
11759     }
11760   }
11761
11762   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11763   return jresult;
11764 }
11765
11766
11767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11768   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11769
11770   arg1 = (Dali::Quaternion *)jarg1;
11771   {
11772     try {
11773       (arg1)->Conjugate();
11774     } catch (std::out_of_range& e) {
11775       {
11776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11777       };
11778     } catch (std::exception& e) {
11779       {
11780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11781       };
11782     } catch (Dali::DaliException e) {
11783       {
11784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11785       };
11786     } catch (...) {
11787       {
11788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11789       };
11790     }
11791   }
11792
11793 }
11794
11795
11796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11797   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11798
11799   arg1 = (Dali::Quaternion *)jarg1;
11800   {
11801     try {
11802       (arg1)->Invert();
11803     } catch (std::out_of_range& e) {
11804       {
11805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11806       };
11807     } catch (std::exception& e) {
11808       {
11809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11810       };
11811     } catch (Dali::DaliException e) {
11812       {
11813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11814       };
11815     } catch (...) {
11816       {
11817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11818       };
11819     }
11820   }
11821
11822 }
11823
11824
11825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11826   void * jresult ;
11827   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11828   Dali::Quaternion result;
11829
11830   arg1 = (Dali::Quaternion *)jarg1;
11831   {
11832     try {
11833       result = ((Dali::Quaternion const *)arg1)->Log();
11834     } catch (std::out_of_range& e) {
11835       {
11836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11837       };
11838     } catch (std::exception& e) {
11839       {
11840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11841       };
11842     } catch (Dali::DaliException e) {
11843       {
11844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11845       };
11846     } catch (...) {
11847       {
11848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11849       };
11850     }
11851   }
11852
11853   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11854   return jresult;
11855 }
11856
11857
11858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11859   void * jresult ;
11860   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11861   Dali::Quaternion result;
11862
11863   arg1 = (Dali::Quaternion *)jarg1;
11864   {
11865     try {
11866       result = ((Dali::Quaternion const *)arg1)->Exp();
11867     } catch (std::out_of_range& e) {
11868       {
11869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11870       };
11871     } catch (std::exception& e) {
11872       {
11873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11874       };
11875     } catch (Dali::DaliException e) {
11876       {
11877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11878       };
11879     } catch (...) {
11880       {
11881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11882       };
11883     }
11884   }
11885
11886   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11887   return jresult;
11888 }
11889
11890
11891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11892   float jresult ;
11893   Dali::Quaternion *arg1 = 0 ;
11894   Dali::Quaternion *arg2 = 0 ;
11895   float result;
11896
11897   arg1 = (Dali::Quaternion *)jarg1;
11898   if (!arg1) {
11899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11900     return 0;
11901   }
11902   arg2 = (Dali::Quaternion *)jarg2;
11903   if (!arg2) {
11904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11905     return 0;
11906   }
11907   {
11908     try {
11909       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11910     } catch (std::out_of_range& e) {
11911       {
11912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11913       };
11914     } catch (std::exception& e) {
11915       {
11916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11917       };
11918     } catch (Dali::DaliException e) {
11919       {
11920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11921       };
11922     } catch (...) {
11923       {
11924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11925       };
11926     }
11927   }
11928
11929   jresult = result;
11930   return jresult;
11931 }
11932
11933
11934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11935   void * jresult ;
11936   Dali::Quaternion *arg1 = 0 ;
11937   Dali::Quaternion *arg2 = 0 ;
11938   float arg3 ;
11939   Dali::Quaternion result;
11940
11941   arg1 = (Dali::Quaternion *)jarg1;
11942   if (!arg1) {
11943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11944     return 0;
11945   }
11946   arg2 = (Dali::Quaternion *)jarg2;
11947   if (!arg2) {
11948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11949     return 0;
11950   }
11951   arg3 = (float)jarg3;
11952   {
11953     try {
11954       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11955     } catch (std::out_of_range& e) {
11956       {
11957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11958       };
11959     } catch (std::exception& e) {
11960       {
11961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11962       };
11963     } catch (Dali::DaliException e) {
11964       {
11965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11966       };
11967     } catch (...) {
11968       {
11969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11970       };
11971     }
11972   }
11973
11974   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11975   return jresult;
11976 }
11977
11978
11979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11980   void * jresult ;
11981   Dali::Quaternion *arg1 = 0 ;
11982   Dali::Quaternion *arg2 = 0 ;
11983   float arg3 ;
11984   Dali::Quaternion result;
11985
11986   arg1 = (Dali::Quaternion *)jarg1;
11987   if (!arg1) {
11988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11989     return 0;
11990   }
11991   arg2 = (Dali::Quaternion *)jarg2;
11992   if (!arg2) {
11993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11994     return 0;
11995   }
11996   arg3 = (float)jarg3;
11997   {
11998     try {
11999       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12000     } catch (std::out_of_range& e) {
12001       {
12002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12003       };
12004     } catch (std::exception& e) {
12005       {
12006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12007       };
12008     } catch (Dali::DaliException e) {
12009       {
12010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12011       };
12012     } catch (...) {
12013       {
12014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12015       };
12016     }
12017   }
12018
12019   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12020   return jresult;
12021 }
12022
12023
12024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12025   void * jresult ;
12026   Dali::Quaternion *arg1 = 0 ;
12027   Dali::Quaternion *arg2 = 0 ;
12028   float arg3 ;
12029   Dali::Quaternion result;
12030
12031   arg1 = (Dali::Quaternion *)jarg1;
12032   if (!arg1) {
12033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12034     return 0;
12035   }
12036   arg2 = (Dali::Quaternion *)jarg2;
12037   if (!arg2) {
12038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12039     return 0;
12040   }
12041   arg3 = (float)jarg3;
12042   {
12043     try {
12044       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12045     } catch (std::out_of_range& e) {
12046       {
12047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12048       };
12049     } catch (std::exception& e) {
12050       {
12051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12052       };
12053     } catch (Dali::DaliException e) {
12054       {
12055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12056       };
12057     } catch (...) {
12058       {
12059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12060       };
12061     }
12062   }
12063
12064   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12065   return jresult;
12066 }
12067
12068
12069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12070   void * jresult ;
12071   Dali::Quaternion *arg1 = 0 ;
12072   Dali::Quaternion *arg2 = 0 ;
12073   Dali::Quaternion *arg3 = 0 ;
12074   Dali::Quaternion *arg4 = 0 ;
12075   float arg5 ;
12076   Dali::Quaternion result;
12077
12078   arg1 = (Dali::Quaternion *)jarg1;
12079   if (!arg1) {
12080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12081     return 0;
12082   }
12083   arg2 = (Dali::Quaternion *)jarg2;
12084   if (!arg2) {
12085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12086     return 0;
12087   }
12088   arg3 = (Dali::Quaternion *)jarg3;
12089   if (!arg3) {
12090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12091     return 0;
12092   }
12093   arg4 = (Dali::Quaternion *)jarg4;
12094   if (!arg4) {
12095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12096     return 0;
12097   }
12098   arg5 = (float)jarg5;
12099   {
12100     try {
12101       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12102     } catch (std::out_of_range& e) {
12103       {
12104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12105       };
12106     } catch (std::exception& e) {
12107       {
12108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12109       };
12110     } catch (Dali::DaliException e) {
12111       {
12112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12113       };
12114     } catch (...) {
12115       {
12116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12117       };
12118     }
12119   }
12120
12121   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12122   return jresult;
12123 }
12124
12125
12126 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12127   float jresult ;
12128   Dali::Quaternion *arg1 = 0 ;
12129   Dali::Quaternion *arg2 = 0 ;
12130   float result;
12131
12132   arg1 = (Dali::Quaternion *)jarg1;
12133   if (!arg1) {
12134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12135     return 0;
12136   }
12137   arg2 = (Dali::Quaternion *)jarg2;
12138   if (!arg2) {
12139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12140     return 0;
12141   }
12142   {
12143     try {
12144       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12145     } catch (std::out_of_range& e) {
12146       {
12147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12148       };
12149     } catch (std::exception& e) {
12150       {
12151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12152       };
12153     } catch (Dali::DaliException e) {
12154       {
12155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12156       };
12157     } catch (...) {
12158       {
12159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12160       };
12161     }
12162   }
12163
12164   jresult = result;
12165   return jresult;
12166 }
12167
12168
12169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12170   void * jresult ;
12171   Dali::Matrix *result = 0 ;
12172
12173   {
12174     try {
12175       result = (Dali::Matrix *)new Dali::Matrix();
12176     } catch (std::out_of_range& e) {
12177       {
12178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12179       };
12180     } catch (std::exception& e) {
12181       {
12182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12183       };
12184     } catch (Dali::DaliException e) {
12185       {
12186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12187       };
12188     } catch (...) {
12189       {
12190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12191       };
12192     }
12193   }
12194
12195   jresult = (void *)result;
12196   return jresult;
12197 }
12198
12199
12200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12201   void * jresult ;
12202   bool arg1 ;
12203   Dali::Matrix *result = 0 ;
12204
12205   arg1 = jarg1 ? true : false;
12206   {
12207     try {
12208       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12209     } catch (std::out_of_range& e) {
12210       {
12211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12212       };
12213     } catch (std::exception& e) {
12214       {
12215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12216       };
12217     } catch (Dali::DaliException e) {
12218       {
12219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12220       };
12221     } catch (...) {
12222       {
12223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12224       };
12225     }
12226   }
12227
12228   jresult = (void *)result;
12229   return jresult;
12230 }
12231
12232
12233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12234   void * jresult ;
12235   float *arg1 = (float *) 0 ;
12236   Dali::Matrix *result = 0 ;
12237
12238   arg1 = jarg1;
12239   {
12240     try {
12241       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12242     } catch (std::out_of_range& e) {
12243       {
12244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12245       };
12246     } catch (std::exception& e) {
12247       {
12248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12249       };
12250     } catch (Dali::DaliException e) {
12251       {
12252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12253       };
12254     } catch (...) {
12255       {
12256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12257       };
12258     }
12259   }
12260
12261   jresult = (void *)result;
12262
12263
12264   return jresult;
12265 }
12266
12267
12268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12269   void * jresult ;
12270   Dali::Quaternion *arg1 = 0 ;
12271   Dali::Matrix *result = 0 ;
12272
12273   arg1 = (Dali::Quaternion *)jarg1;
12274   if (!arg1) {
12275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12276     return 0;
12277   }
12278   {
12279     try {
12280       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12281     } catch (std::out_of_range& e) {
12282       {
12283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12284       };
12285     } catch (std::exception& e) {
12286       {
12287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12288       };
12289     } catch (Dali::DaliException e) {
12290       {
12291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12292       };
12293     } catch (...) {
12294       {
12295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12296       };
12297     }
12298   }
12299
12300   jresult = (void *)result;
12301   return jresult;
12302 }
12303
12304
12305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12306   void * jresult ;
12307   Dali::Matrix *arg1 = 0 ;
12308   Dali::Matrix *result = 0 ;
12309
12310   arg1 = (Dali::Matrix *)jarg1;
12311   if (!arg1) {
12312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12313     return 0;
12314   }
12315   {
12316     try {
12317       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12318     } catch (std::out_of_range& e) {
12319       {
12320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12321       };
12322     } catch (std::exception& e) {
12323       {
12324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12325       };
12326     } catch (Dali::DaliException e) {
12327       {
12328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12329       };
12330     } catch (...) {
12331       {
12332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12333       };
12334     }
12335   }
12336
12337   jresult = (void *)result;
12338   return jresult;
12339 }
12340
12341
12342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12343   void * jresult ;
12344   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12345   Dali::Matrix *arg2 = 0 ;
12346   Dali::Matrix *result = 0 ;
12347
12348   arg1 = (Dali::Matrix *)jarg1;
12349   arg2 = (Dali::Matrix *)jarg2;
12350   if (!arg2) {
12351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12352     return 0;
12353   }
12354   {
12355     try {
12356       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12357     } catch (std::out_of_range& e) {
12358       {
12359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12360       };
12361     } catch (std::exception& e) {
12362       {
12363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12364       };
12365     } catch (Dali::DaliException e) {
12366       {
12367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12368       };
12369     } catch (...) {
12370       {
12371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12372       };
12373     }
12374   }
12375
12376   jresult = (void *)result;
12377   return jresult;
12378 }
12379
12380
12381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12382   void * jresult ;
12383   Dali::Matrix *result = 0 ;
12384
12385   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12386   jresult = (void *)result;
12387   return jresult;
12388 }
12389
12390
12391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12392   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12393
12394   arg1 = (Dali::Matrix *)jarg1;
12395   {
12396     try {
12397       (arg1)->SetIdentity();
12398     } catch (std::out_of_range& e) {
12399       {
12400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12401       };
12402     } catch (std::exception& e) {
12403       {
12404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12405       };
12406     } catch (Dali::DaliException e) {
12407       {
12408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12409       };
12410     } catch (...) {
12411       {
12412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12413       };
12414     }
12415   }
12416
12417 }
12418
12419
12420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12421   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12422   Dali::Vector3 *arg2 = 0 ;
12423
12424   arg1 = (Dali::Matrix *)jarg1;
12425   arg2 = (Dali::Vector3 *)jarg2;
12426   if (!arg2) {
12427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12428     return ;
12429   }
12430   {
12431     try {
12432       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12433     } catch (std::out_of_range& e) {
12434       {
12435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12436       };
12437     } catch (std::exception& e) {
12438       {
12439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12440       };
12441     } catch (Dali::DaliException e) {
12442       {
12443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12444       };
12445     } catch (...) {
12446       {
12447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12448       };
12449     }
12450   }
12451
12452 }
12453
12454
12455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12456   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12457   Dali::Matrix *arg2 = 0 ;
12458
12459   arg1 = (Dali::Matrix *)jarg1;
12460   arg2 = (Dali::Matrix *)jarg2;
12461   if (!arg2) {
12462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12463     return ;
12464   }
12465   {
12466     try {
12467       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12468     } catch (std::out_of_range& e) {
12469       {
12470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12471       };
12472     } catch (std::exception& e) {
12473       {
12474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12475       };
12476     } catch (Dali::DaliException e) {
12477       {
12478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12479       };
12480     } catch (...) {
12481       {
12482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12483       };
12484     }
12485   }
12486
12487 }
12488
12489
12490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12491   unsigned int jresult ;
12492   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12493   bool result;
12494
12495   arg1 = (Dali::Matrix *)jarg1;
12496   {
12497     try {
12498       result = (bool)(arg1)->Invert();
12499     } catch (std::out_of_range& e) {
12500       {
12501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12502       };
12503     } catch (std::exception& e) {
12504       {
12505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12506       };
12507     } catch (Dali::DaliException e) {
12508       {
12509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12510       };
12511     } catch (...) {
12512       {
12513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12514       };
12515     }
12516   }
12517
12518   jresult = result;
12519   return jresult;
12520 }
12521
12522
12523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12524   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12525
12526   arg1 = (Dali::Matrix *)jarg1;
12527   {
12528     try {
12529       (arg1)->Transpose();
12530     } catch (std::out_of_range& e) {
12531       {
12532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12533       };
12534     } catch (std::exception& e) {
12535       {
12536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12537       };
12538     } catch (Dali::DaliException e) {
12539       {
12540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12541       };
12542     } catch (...) {
12543       {
12544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12545       };
12546     }
12547   }
12548
12549 }
12550
12551
12552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12553   void * jresult ;
12554   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12555   Dali::Vector3 result;
12556
12557   arg1 = (Dali::Matrix *)jarg1;
12558   {
12559     try {
12560       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12561     } catch (std::out_of_range& e) {
12562       {
12563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12564       };
12565     } catch (std::exception& e) {
12566       {
12567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12568       };
12569     } catch (Dali::DaliException e) {
12570       {
12571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12572       };
12573     } catch (...) {
12574       {
12575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12576       };
12577     }
12578   }
12579
12580   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12581   return jresult;
12582 }
12583
12584
12585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12586   void * jresult ;
12587   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12588   Dali::Vector3 result;
12589
12590   arg1 = (Dali::Matrix *)jarg1;
12591   {
12592     try {
12593       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12594     } catch (std::out_of_range& e) {
12595       {
12596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12597       };
12598     } catch (std::exception& e) {
12599       {
12600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12601       };
12602     } catch (Dali::DaliException e) {
12603       {
12604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12605       };
12606     } catch (...) {
12607       {
12608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12609       };
12610     }
12611   }
12612
12613   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12614   return jresult;
12615 }
12616
12617
12618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12619   void * jresult ;
12620   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12621   Dali::Vector3 result;
12622
12623   arg1 = (Dali::Matrix *)jarg1;
12624   {
12625     try {
12626       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12627     } catch (std::out_of_range& e) {
12628       {
12629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12630       };
12631     } catch (std::exception& e) {
12632       {
12633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12634       };
12635     } catch (Dali::DaliException e) {
12636       {
12637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12638       };
12639     } catch (...) {
12640       {
12641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12642       };
12643     }
12644   }
12645
12646   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12647   return jresult;
12648 }
12649
12650
12651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12652   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12653   Dali::Vector3 *arg2 = 0 ;
12654
12655   arg1 = (Dali::Matrix *)jarg1;
12656   arg2 = (Dali::Vector3 *)jarg2;
12657   if (!arg2) {
12658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12659     return ;
12660   }
12661   {
12662     try {
12663       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12664     } catch (std::out_of_range& e) {
12665       {
12666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12667       };
12668     } catch (std::exception& e) {
12669       {
12670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12671       };
12672     } catch (Dali::DaliException e) {
12673       {
12674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12675       };
12676     } catch (...) {
12677       {
12678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12679       };
12680     }
12681   }
12682
12683 }
12684
12685
12686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12687   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12688   Dali::Vector3 *arg2 = 0 ;
12689
12690   arg1 = (Dali::Matrix *)jarg1;
12691   arg2 = (Dali::Vector3 *)jarg2;
12692   if (!arg2) {
12693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12694     return ;
12695   }
12696   {
12697     try {
12698       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12699     } catch (std::out_of_range& e) {
12700       {
12701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12702       };
12703     } catch (std::exception& e) {
12704       {
12705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12706       };
12707     } catch (Dali::DaliException e) {
12708       {
12709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12710       };
12711     } catch (...) {
12712       {
12713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12714       };
12715     }
12716   }
12717
12718 }
12719
12720
12721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12722   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12723   Dali::Vector3 *arg2 = 0 ;
12724
12725   arg1 = (Dali::Matrix *)jarg1;
12726   arg2 = (Dali::Vector3 *)jarg2;
12727   if (!arg2) {
12728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12729     return ;
12730   }
12731   {
12732     try {
12733       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12734     } catch (std::out_of_range& e) {
12735       {
12736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12737       };
12738     } catch (std::exception& e) {
12739       {
12740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12741       };
12742     } catch (Dali::DaliException e) {
12743       {
12744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12745       };
12746     } catch (...) {
12747       {
12748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12749       };
12750     }
12751   }
12752
12753 }
12754
12755
12756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12757   void * jresult ;
12758   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12759   Dali::Vector4 *result = 0 ;
12760
12761   arg1 = (Dali::Matrix *)jarg1;
12762   {
12763     try {
12764       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12765     } catch (std::out_of_range& e) {
12766       {
12767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12768       };
12769     } catch (std::exception& e) {
12770       {
12771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12772       };
12773     } catch (Dali::DaliException e) {
12774       {
12775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12776       };
12777     } catch (...) {
12778       {
12779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12780       };
12781     }
12782   }
12783
12784   jresult = (void *)result;
12785   return jresult;
12786 }
12787
12788
12789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12790   void * jresult ;
12791   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12792   Dali::Vector3 *result = 0 ;
12793
12794   arg1 = (Dali::Matrix *)jarg1;
12795   {
12796     try {
12797       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12798     } catch (std::out_of_range& e) {
12799       {
12800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12801       };
12802     } catch (std::exception& e) {
12803       {
12804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12805       };
12806     } catch (Dali::DaliException e) {
12807       {
12808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12809       };
12810     } catch (...) {
12811       {
12812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12813       };
12814     }
12815   }
12816
12817   jresult = (void *)result;
12818   return jresult;
12819 }
12820
12821
12822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12823   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12824   Dali::Vector4 *arg2 = 0 ;
12825
12826   arg1 = (Dali::Matrix *)jarg1;
12827   arg2 = (Dali::Vector4 *)jarg2;
12828   if (!arg2) {
12829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12830     return ;
12831   }
12832   {
12833     try {
12834       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12835     } catch (std::out_of_range& e) {
12836       {
12837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12838       };
12839     } catch (std::exception& e) {
12840       {
12841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12842       };
12843     } catch (Dali::DaliException e) {
12844       {
12845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12846       };
12847     } catch (...) {
12848       {
12849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12850       };
12851     }
12852   }
12853
12854 }
12855
12856
12857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12858   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12859   Dali::Vector3 *arg2 = 0 ;
12860
12861   arg1 = (Dali::Matrix *)jarg1;
12862   arg2 = (Dali::Vector3 *)jarg2;
12863   if (!arg2) {
12864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12865     return ;
12866   }
12867   {
12868     try {
12869       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12870     } catch (std::out_of_range& e) {
12871       {
12872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12873       };
12874     } catch (std::exception& e) {
12875       {
12876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12877       };
12878     } catch (Dali::DaliException e) {
12879       {
12880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12881       };
12882     } catch (...) {
12883       {
12884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12885       };
12886     }
12887   }
12888
12889 }
12890
12891
12892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12893   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12894
12895   arg1 = (Dali::Matrix *)jarg1;
12896   {
12897     try {
12898       (arg1)->OrthoNormalize();
12899     } catch (std::out_of_range& e) {
12900       {
12901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12902       };
12903     } catch (std::exception& e) {
12904       {
12905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12906       };
12907     } catch (Dali::DaliException e) {
12908       {
12909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12910       };
12911     } catch (...) {
12912       {
12913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12914       };
12915     }
12916   }
12917
12918 }
12919
12920
12921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12922   void * jresult ;
12923   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12924   float *result = 0 ;
12925
12926   arg1 = (Dali::Matrix *)jarg1;
12927   {
12928     try {
12929       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12930     } catch (std::out_of_range& e) {
12931       {
12932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12933       };
12934     } catch (std::exception& e) {
12935       {
12936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12937       };
12938     } catch (Dali::DaliException e) {
12939       {
12940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12941       };
12942     } catch (...) {
12943       {
12944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12945       };
12946     }
12947   }
12948
12949   jresult = (void *)result;
12950   return jresult;
12951 }
12952
12953
12954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12955   Dali::Matrix *arg1 = 0 ;
12956   Dali::Matrix *arg2 = 0 ;
12957   Dali::Matrix *arg3 = 0 ;
12958
12959   arg1 = (Dali::Matrix *)jarg1;
12960   if (!arg1) {
12961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12962     return ;
12963   }
12964   arg2 = (Dali::Matrix *)jarg2;
12965   if (!arg2) {
12966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12967     return ;
12968   }
12969   arg3 = (Dali::Matrix *)jarg3;
12970   if (!arg3) {
12971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12972     return ;
12973   }
12974   {
12975     try {
12976       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12977     } catch (std::out_of_range& e) {
12978       {
12979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12980       };
12981     } catch (std::exception& e) {
12982       {
12983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12984       };
12985     } catch (Dali::DaliException e) {
12986       {
12987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12988       };
12989     } catch (...) {
12990       {
12991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12992       };
12993     }
12994   }
12995
12996 }
12997
12998
12999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13000   Dali::Matrix *arg1 = 0 ;
13001   Dali::Matrix *arg2 = 0 ;
13002   Dali::Quaternion *arg3 = 0 ;
13003
13004   arg1 = (Dali::Matrix *)jarg1;
13005   if (!arg1) {
13006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13007     return ;
13008   }
13009   arg2 = (Dali::Matrix *)jarg2;
13010   if (!arg2) {
13011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13012     return ;
13013   }
13014   arg3 = (Dali::Quaternion *)jarg3;
13015   if (!arg3) {
13016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13017     return ;
13018   }
13019   {
13020     try {
13021       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13022     } catch (std::out_of_range& e) {
13023       {
13024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13025       };
13026     } catch (std::exception& e) {
13027       {
13028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13029       };
13030     } catch (Dali::DaliException e) {
13031       {
13032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13033       };
13034     } catch (...) {
13035       {
13036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13037       };
13038     }
13039   }
13040
13041 }
13042
13043
13044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13045   void * jresult ;
13046   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13047   Dali::Vector4 *arg2 = 0 ;
13048   Dali::Vector4 result;
13049
13050   arg1 = (Dali::Matrix *)jarg1;
13051   arg2 = (Dali::Vector4 *)jarg2;
13052   if (!arg2) {
13053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13054     return 0;
13055   }
13056   {
13057     try {
13058       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13059     } catch (std::out_of_range& e) {
13060       {
13061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13062       };
13063     } catch (std::exception& e) {
13064       {
13065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13066       };
13067     } catch (Dali::DaliException e) {
13068       {
13069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13070       };
13071     } catch (...) {
13072       {
13073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13074       };
13075     }
13076   }
13077
13078   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13079   return jresult;
13080 }
13081
13082
13083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13084   unsigned int jresult ;
13085   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13086   Dali::Matrix *arg2 = 0 ;
13087   bool result;
13088
13089   arg1 = (Dali::Matrix *)jarg1;
13090   arg2 = (Dali::Matrix *)jarg2;
13091   if (!arg2) {
13092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13093     return 0;
13094   }
13095   {
13096     try {
13097       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13098     } catch (std::out_of_range& e) {
13099       {
13100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13101       };
13102     } catch (std::exception& e) {
13103       {
13104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13105       };
13106     } catch (Dali::DaliException e) {
13107       {
13108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13109       };
13110     } catch (...) {
13111       {
13112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13113       };
13114     }
13115   }
13116
13117   jresult = result;
13118   return jresult;
13119 }
13120
13121
13122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13123   unsigned int jresult ;
13124   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13125   Dali::Matrix *arg2 = 0 ;
13126   bool result;
13127
13128   arg1 = (Dali::Matrix *)jarg1;
13129   arg2 = (Dali::Matrix *)jarg2;
13130   if (!arg2) {
13131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13132     return 0;
13133   }
13134   {
13135     try {
13136       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13137     } catch (std::out_of_range& e) {
13138       {
13139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13140       };
13141     } catch (std::exception& e) {
13142       {
13143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13144       };
13145     } catch (Dali::DaliException e) {
13146       {
13147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13148       };
13149     } catch (...) {
13150       {
13151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13152       };
13153     }
13154   }
13155
13156   jresult = result;
13157   return jresult;
13158 }
13159
13160
13161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13162   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13163   Dali::Vector3 *arg2 = 0 ;
13164   Dali::Quaternion *arg3 = 0 ;
13165   Dali::Vector3 *arg4 = 0 ;
13166
13167   arg1 = (Dali::Matrix *)jarg1;
13168   arg2 = (Dali::Vector3 *)jarg2;
13169   if (!arg2) {
13170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13171     return ;
13172   }
13173   arg3 = (Dali::Quaternion *)jarg3;
13174   if (!arg3) {
13175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13176     return ;
13177   }
13178   arg4 = (Dali::Vector3 *)jarg4;
13179   if (!arg4) {
13180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13181     return ;
13182   }
13183   {
13184     try {
13185       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13186     } catch (std::out_of_range& e) {
13187       {
13188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13189       };
13190     } catch (std::exception& e) {
13191       {
13192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13193       };
13194     } catch (Dali::DaliException e) {
13195       {
13196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13197       };
13198     } catch (...) {
13199       {
13200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13201       };
13202     }
13203   }
13204
13205 }
13206
13207
13208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13209   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13210   Dali::Vector3 *arg2 = 0 ;
13211   Dali::Quaternion *arg3 = 0 ;
13212   Dali::Vector3 *arg4 = 0 ;
13213
13214   arg1 = (Dali::Matrix *)jarg1;
13215   arg2 = (Dali::Vector3 *)jarg2;
13216   if (!arg2) {
13217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13218     return ;
13219   }
13220   arg3 = (Dali::Quaternion *)jarg3;
13221   if (!arg3) {
13222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13223     return ;
13224   }
13225   arg4 = (Dali::Vector3 *)jarg4;
13226   if (!arg4) {
13227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13228     return ;
13229   }
13230   {
13231     try {
13232       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13233     } catch (std::out_of_range& e) {
13234       {
13235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13236       };
13237     } catch (std::exception& e) {
13238       {
13239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13240       };
13241     } catch (Dali::DaliException e) {
13242       {
13243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13244       };
13245     } catch (...) {
13246       {
13247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13248       };
13249     }
13250   }
13251
13252 }
13253
13254
13255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13256   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13257   Dali::Vector3 *arg2 = 0 ;
13258   Dali::Vector3 *arg3 = 0 ;
13259   Dali::Vector3 *arg4 = 0 ;
13260   Dali::Vector3 *arg5 = 0 ;
13261
13262   arg1 = (Dali::Matrix *)jarg1;
13263   arg2 = (Dali::Vector3 *)jarg2;
13264   if (!arg2) {
13265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13266     return ;
13267   }
13268   arg3 = (Dali::Vector3 *)jarg3;
13269   if (!arg3) {
13270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13271     return ;
13272   }
13273   arg4 = (Dali::Vector3 *)jarg4;
13274   if (!arg4) {
13275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13276     return ;
13277   }
13278   arg5 = (Dali::Vector3 *)jarg5;
13279   if (!arg5) {
13280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13281     return ;
13282   }
13283   {
13284     try {
13285       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13286     } catch (std::out_of_range& e) {
13287       {
13288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13289       };
13290     } catch (std::exception& e) {
13291       {
13292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13293       };
13294     } catch (Dali::DaliException e) {
13295       {
13296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13297       };
13298     } catch (...) {
13299       {
13300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13301       };
13302     }
13303   }
13304
13305 }
13306
13307
13308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13309   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13310   Dali::Vector3 *arg2 = 0 ;
13311   Dali::Quaternion *arg3 = 0 ;
13312   Dali::Vector3 *arg4 = 0 ;
13313
13314   arg1 = (Dali::Matrix *)jarg1;
13315   arg2 = (Dali::Vector3 *)jarg2;
13316   if (!arg2) {
13317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13318     return ;
13319   }
13320   arg3 = (Dali::Quaternion *)jarg3;
13321   if (!arg3) {
13322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13323     return ;
13324   }
13325   arg4 = (Dali::Vector3 *)jarg4;
13326   if (!arg4) {
13327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13328     return ;
13329   }
13330   {
13331     try {
13332       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13333     } catch (std::out_of_range& e) {
13334       {
13335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13336       };
13337     } catch (std::exception& e) {
13338       {
13339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13340       };
13341     } catch (Dali::DaliException e) {
13342       {
13343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13344       };
13345     } catch (...) {
13346       {
13347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13348       };
13349     }
13350   }
13351
13352 }
13353
13354
13355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13356   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13357
13358   arg1 = (Dali::Matrix *)jarg1;
13359   {
13360     try {
13361       delete arg1;
13362     } catch (std::out_of_range& e) {
13363       {
13364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13365       };
13366     } catch (std::exception& e) {
13367       {
13368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13369       };
13370     } catch (Dali::DaliException e) {
13371       {
13372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13373       };
13374     } catch (...) {
13375       {
13376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13377       };
13378     }
13379   }
13380
13381 }
13382
13383
13384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13385   void * jresult ;
13386   Dali::Matrix3 *result = 0 ;
13387
13388   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13389   jresult = (void *)result;
13390   return jresult;
13391 }
13392
13393
13394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13395   void * jresult ;
13396   Dali::Matrix3 *result = 0 ;
13397
13398   {
13399     try {
13400       result = (Dali::Matrix3 *)new Dali::Matrix3();
13401     } catch (std::out_of_range& e) {
13402       {
13403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13404       };
13405     } catch (std::exception& e) {
13406       {
13407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13408       };
13409     } catch (Dali::DaliException e) {
13410       {
13411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13412       };
13413     } catch (...) {
13414       {
13415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13416       };
13417     }
13418   }
13419
13420   jresult = (void *)result;
13421   return jresult;
13422 }
13423
13424
13425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13426   void * jresult ;
13427   Dali::Matrix3 *arg1 = 0 ;
13428   Dali::Matrix3 *result = 0 ;
13429
13430   arg1 = (Dali::Matrix3 *)jarg1;
13431   if (!arg1) {
13432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13433     return 0;
13434   }
13435   {
13436     try {
13437       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13438     } catch (std::out_of_range& e) {
13439       {
13440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13441       };
13442     } catch (std::exception& e) {
13443       {
13444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13445       };
13446     } catch (Dali::DaliException e) {
13447       {
13448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13449       };
13450     } catch (...) {
13451       {
13452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13453       };
13454     }
13455   }
13456
13457   jresult = (void *)result;
13458   return jresult;
13459 }
13460
13461
13462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13463   void * jresult ;
13464   Dali::Matrix *arg1 = 0 ;
13465   Dali::Matrix3 *result = 0 ;
13466
13467   arg1 = (Dali::Matrix *)jarg1;
13468   if (!arg1) {
13469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13470     return 0;
13471   }
13472   {
13473     try {
13474       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13475     } catch (std::out_of_range& e) {
13476       {
13477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13478       };
13479     } catch (std::exception& e) {
13480       {
13481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13482       };
13483     } catch (Dali::DaliException e) {
13484       {
13485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13486       };
13487     } catch (...) {
13488       {
13489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13490       };
13491     }
13492   }
13493
13494   jresult = (void *)result;
13495   return jresult;
13496 }
13497
13498
13499 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) {
13500   void * jresult ;
13501   float arg1 ;
13502   float arg2 ;
13503   float arg3 ;
13504   float arg4 ;
13505   float arg5 ;
13506   float arg6 ;
13507   float arg7 ;
13508   float arg8 ;
13509   float arg9 ;
13510   Dali::Matrix3 *result = 0 ;
13511
13512   arg1 = (float)jarg1;
13513   arg2 = (float)jarg2;
13514   arg3 = (float)jarg3;
13515   arg4 = (float)jarg4;
13516   arg5 = (float)jarg5;
13517   arg6 = (float)jarg6;
13518   arg7 = (float)jarg7;
13519   arg8 = (float)jarg8;
13520   arg9 = (float)jarg9;
13521   {
13522     try {
13523       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13524     } catch (std::out_of_range& e) {
13525       {
13526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13527       };
13528     } catch (std::exception& e) {
13529       {
13530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13531       };
13532     } catch (Dali::DaliException e) {
13533       {
13534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13535       };
13536     } catch (...) {
13537       {
13538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13539       };
13540     }
13541   }
13542
13543   jresult = (void *)result;
13544   return jresult;
13545 }
13546
13547
13548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13549   void * jresult ;
13550   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13551   Dali::Matrix3 *arg2 = 0 ;
13552   Dali::Matrix3 *result = 0 ;
13553
13554   arg1 = (Dali::Matrix3 *)jarg1;
13555   arg2 = (Dali::Matrix3 *)jarg2;
13556   if (!arg2) {
13557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13558     return 0;
13559   }
13560   {
13561     try {
13562       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13563     } catch (std::out_of_range& e) {
13564       {
13565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13566       };
13567     } catch (std::exception& e) {
13568       {
13569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13570       };
13571     } catch (Dali::DaliException e) {
13572       {
13573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13574       };
13575     } catch (...) {
13576       {
13577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13578       };
13579     }
13580   }
13581
13582   jresult = (void *)result;
13583   return jresult;
13584 }
13585
13586
13587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13588   void * jresult ;
13589   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13590   Dali::Matrix *arg2 = 0 ;
13591   Dali::Matrix3 *result = 0 ;
13592
13593   arg1 = (Dali::Matrix3 *)jarg1;
13594   arg2 = (Dali::Matrix *)jarg2;
13595   if (!arg2) {
13596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13597     return 0;
13598   }
13599   {
13600     try {
13601       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13602     } catch (std::out_of_range& e) {
13603       {
13604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13605       };
13606     } catch (std::exception& e) {
13607       {
13608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13609       };
13610     } catch (Dali::DaliException e) {
13611       {
13612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13613       };
13614     } catch (...) {
13615       {
13616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13617       };
13618     }
13619   }
13620
13621   jresult = (void *)result;
13622   return jresult;
13623 }
13624
13625
13626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13627   unsigned int jresult ;
13628   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13629   Dali::Matrix3 *arg2 = 0 ;
13630   bool result;
13631
13632   arg1 = (Dali::Matrix3 *)jarg1;
13633   arg2 = (Dali::Matrix3 *)jarg2;
13634   if (!arg2) {
13635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13636     return 0;
13637   }
13638   {
13639     try {
13640       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13641     } catch (std::out_of_range& e) {
13642       {
13643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13644       };
13645     } catch (std::exception& e) {
13646       {
13647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13648       };
13649     } catch (Dali::DaliException e) {
13650       {
13651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13652       };
13653     } catch (...) {
13654       {
13655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13656       };
13657     }
13658   }
13659
13660   jresult = result;
13661   return jresult;
13662 }
13663
13664
13665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13666   unsigned int jresult ;
13667   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13668   Dali::Matrix3 *arg2 = 0 ;
13669   bool result;
13670
13671   arg1 = (Dali::Matrix3 *)jarg1;
13672   arg2 = (Dali::Matrix3 *)jarg2;
13673   if (!arg2) {
13674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13675     return 0;
13676   }
13677   {
13678     try {
13679       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13680     } catch (std::out_of_range& e) {
13681       {
13682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13683       };
13684     } catch (std::exception& e) {
13685       {
13686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13687       };
13688     } catch (Dali::DaliException e) {
13689       {
13690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13691       };
13692     } catch (...) {
13693       {
13694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13695       };
13696     }
13697   }
13698
13699   jresult = result;
13700   return jresult;
13701 }
13702
13703
13704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13705   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13706
13707   arg1 = (Dali::Matrix3 *)jarg1;
13708   {
13709     try {
13710       delete arg1;
13711     } catch (std::out_of_range& e) {
13712       {
13713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13714       };
13715     } catch (std::exception& e) {
13716       {
13717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13718       };
13719     } catch (Dali::DaliException e) {
13720       {
13721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13722       };
13723     } catch (...) {
13724       {
13725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13726       };
13727     }
13728   }
13729
13730 }
13731
13732
13733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13734   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13735
13736   arg1 = (Dali::Matrix3 *)jarg1;
13737   {
13738     try {
13739       (arg1)->SetIdentity();
13740     } catch (std::out_of_range& e) {
13741       {
13742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13743       };
13744     } catch (std::exception& e) {
13745       {
13746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13747       };
13748     } catch (Dali::DaliException e) {
13749       {
13750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13751       };
13752     } catch (...) {
13753       {
13754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13755       };
13756     }
13757   }
13758
13759 }
13760
13761
13762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13763   void * jresult ;
13764   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13765   float *result = 0 ;
13766
13767   arg1 = (Dali::Matrix3 *)jarg1;
13768   {
13769     try {
13770       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13771     } catch (std::out_of_range& e) {
13772       {
13773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13774       };
13775     } catch (std::exception& e) {
13776       {
13777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13778       };
13779     } catch (Dali::DaliException e) {
13780       {
13781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13782       };
13783     } catch (...) {
13784       {
13785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13786       };
13787     }
13788   }
13789
13790   jresult = (void *)result;
13791   return jresult;
13792 }
13793
13794
13795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13796   unsigned int jresult ;
13797   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13798   bool result;
13799
13800   arg1 = (Dali::Matrix3 *)jarg1;
13801   {
13802     try {
13803       result = (bool)(arg1)->Invert();
13804     } catch (std::out_of_range& e) {
13805       {
13806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13807       };
13808     } catch (std::exception& e) {
13809       {
13810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13811       };
13812     } catch (Dali::DaliException e) {
13813       {
13814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13815       };
13816     } catch (...) {
13817       {
13818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13819       };
13820     }
13821   }
13822
13823   jresult = result;
13824   return jresult;
13825 }
13826
13827
13828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13829   unsigned int jresult ;
13830   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13831   bool result;
13832
13833   arg1 = (Dali::Matrix3 *)jarg1;
13834   {
13835     try {
13836       result = (bool)(arg1)->Transpose();
13837     } catch (std::out_of_range& e) {
13838       {
13839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13840       };
13841     } catch (std::exception& e) {
13842       {
13843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13844       };
13845     } catch (Dali::DaliException e) {
13846       {
13847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13848       };
13849     } catch (...) {
13850       {
13851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13852       };
13853     }
13854   }
13855
13856   jresult = result;
13857   return jresult;
13858 }
13859
13860
13861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13862   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13863   float arg2 ;
13864
13865   arg1 = (Dali::Matrix3 *)jarg1;
13866   arg2 = (float)jarg2;
13867   {
13868     try {
13869       (arg1)->Scale(arg2);
13870     } catch (std::out_of_range& e) {
13871       {
13872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13873       };
13874     } catch (std::exception& e) {
13875       {
13876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13877       };
13878     } catch (Dali::DaliException e) {
13879       {
13880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13881       };
13882     } catch (...) {
13883       {
13884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13885       };
13886     }
13887   }
13888
13889 }
13890
13891
13892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13893   float jresult ;
13894   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13895   float result;
13896
13897   arg1 = (Dali::Matrix3 *)jarg1;
13898   {
13899     try {
13900       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13901     } catch (std::out_of_range& e) {
13902       {
13903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13904       };
13905     } catch (std::exception& e) {
13906       {
13907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13908       };
13909     } catch (Dali::DaliException e) {
13910       {
13911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13912       };
13913     } catch (...) {
13914       {
13915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13916       };
13917     }
13918   }
13919
13920   jresult = result;
13921   return jresult;
13922 }
13923
13924
13925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13926   unsigned int jresult ;
13927   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13928   bool result;
13929
13930   arg1 = (Dali::Matrix3 *)jarg1;
13931   {
13932     try {
13933       result = (bool)(arg1)->ScaledInverseTranspose();
13934     } catch (std::out_of_range& e) {
13935       {
13936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13937       };
13938     } catch (std::exception& e) {
13939       {
13940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13941       };
13942     } catch (Dali::DaliException e) {
13943       {
13944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13945       };
13946     } catch (...) {
13947       {
13948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13949       };
13950     }
13951   }
13952
13953   jresult = result;
13954   return jresult;
13955 }
13956
13957
13958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13959   Dali::Matrix3 *arg1 = 0 ;
13960   Dali::Matrix3 *arg2 = 0 ;
13961   Dali::Matrix3 *arg3 = 0 ;
13962
13963   arg1 = (Dali::Matrix3 *)jarg1;
13964   if (!arg1) {
13965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13966     return ;
13967   }
13968   arg2 = (Dali::Matrix3 *)jarg2;
13969   if (!arg2) {
13970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13971     return ;
13972   }
13973   arg3 = (Dali::Matrix3 *)jarg3;
13974   if (!arg3) {
13975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13976     return ;
13977   }
13978   {
13979     try {
13980       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13981     } catch (std::out_of_range& e) {
13982       {
13983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13984       };
13985     } catch (std::exception& e) {
13986       {
13987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13988       };
13989     } catch (Dali::DaliException e) {
13990       {
13991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13992       };
13993     } catch (...) {
13994       {
13995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13996       };
13997     }
13998   }
13999
14000 }
14001
14002
14003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14004   float jresult ;
14005   float arg1 ;
14006   float arg2 ;
14007   float result;
14008
14009   arg1 = (float)jarg1;
14010   arg2 = (float)jarg2;
14011   {
14012     try {
14013       result = (float)Dali::Random::Range(arg1,arg2);
14014     } catch (std::out_of_range& e) {
14015       {
14016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14017       };
14018     } catch (std::exception& e) {
14019       {
14020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14021       };
14022     } catch (Dali::DaliException e) {
14023       {
14024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14025       };
14026     } catch (...) {
14027       {
14028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14029       };
14030     }
14031   }
14032
14033   jresult = result;
14034   return jresult;
14035 }
14036
14037
14038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14039   void * jresult ;
14040   Dali::Vector4 result;
14041
14042   {
14043     try {
14044       result = Dali::Random::Axis();
14045     } catch (std::out_of_range& e) {
14046       {
14047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14048       };
14049     } catch (std::exception& e) {
14050       {
14051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14052       };
14053     } catch (Dali::DaliException e) {
14054       {
14055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14056       };
14057     } catch (...) {
14058       {
14059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14060       };
14061     }
14062   }
14063
14064   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14065   return jresult;
14066 }
14067
14068
14069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14070   void * jresult ;
14071   Dali::AngleAxis *result = 0 ;
14072
14073   {
14074     try {
14075       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14076     } catch (std::out_of_range& e) {
14077       {
14078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14079       };
14080     } catch (std::exception& e) {
14081       {
14082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14083       };
14084     } catch (Dali::DaliException e) {
14085       {
14086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14087       };
14088     } catch (...) {
14089       {
14090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14091       };
14092     }
14093   }
14094
14095   jresult = (void *)result;
14096   return jresult;
14097 }
14098
14099
14100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14101   void * jresult ;
14102   Dali::Radian arg1 ;
14103   Dali::Vector3 *arg2 = 0 ;
14104   Dali::Radian *argp1 ;
14105   Dali::AngleAxis *result = 0 ;
14106
14107   argp1 = (Dali::Radian *)jarg1;
14108   if (!argp1) {
14109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14110     return 0;
14111   }
14112   arg1 = *argp1;
14113   arg2 = (Dali::Vector3 *)jarg2;
14114   if (!arg2) {
14115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14116     return 0;
14117   }
14118   {
14119     try {
14120       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14121     } catch (std::out_of_range& e) {
14122       {
14123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14124       };
14125     } catch (std::exception& e) {
14126       {
14127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14128       };
14129     } catch (Dali::DaliException e) {
14130       {
14131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14132       };
14133     } catch (...) {
14134       {
14135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14136       };
14137     }
14138   }
14139
14140   jresult = (void *)result;
14141   return jresult;
14142 }
14143
14144
14145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14146   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14147   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14148
14149   arg1 = (Dali::AngleAxis *)jarg1;
14150   arg2 = (Dali::Radian *)jarg2;
14151   if (arg1) (arg1)->angle = *arg2;
14152 }
14153
14154
14155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14156   void * jresult ;
14157   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14158   Dali::Radian *result = 0 ;
14159
14160   arg1 = (Dali::AngleAxis *)jarg1;
14161   result = (Dali::Radian *)& ((arg1)->angle);
14162   jresult = (void *)result;
14163   return jresult;
14164 }
14165
14166
14167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14168   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14169   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14170
14171   arg1 = (Dali::AngleAxis *)jarg1;
14172   arg2 = (Dali::Vector3 *)jarg2;
14173   if (arg1) (arg1)->axis = *arg2;
14174 }
14175
14176
14177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14178   void * jresult ;
14179   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14180   Dali::Vector3 *result = 0 ;
14181
14182   arg1 = (Dali::AngleAxis *)jarg1;
14183   result = (Dali::Vector3 *)& ((arg1)->axis);
14184   jresult = (void *)result;
14185   return jresult;
14186 }
14187
14188
14189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14190   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14191
14192   arg1 = (Dali::AngleAxis *)jarg1;
14193   {
14194     try {
14195       delete arg1;
14196     } catch (std::out_of_range& e) {
14197       {
14198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14199       };
14200     } catch (std::exception& e) {
14201       {
14202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14203       };
14204     } catch (Dali::DaliException e) {
14205       {
14206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14207       };
14208     } catch (...) {
14209       {
14210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14211       };
14212     }
14213   }
14214
14215 }
14216
14217
14218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14219   unsigned int jresult ;
14220   Dali::AngleAxis *arg1 = 0 ;
14221   Dali::AngleAxis *arg2 = 0 ;
14222   bool result;
14223
14224   arg1 = (Dali::AngleAxis *)jarg1;
14225   if (!arg1) {
14226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14227     return 0;
14228   }
14229   arg2 = (Dali::AngleAxis *)jarg2;
14230   if (!arg2) {
14231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14232     return 0;
14233   }
14234   {
14235     try {
14236       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14237     } catch (std::out_of_range& e) {
14238       {
14239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14240       };
14241     } catch (std::exception& e) {
14242       {
14243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14244       };
14245     } catch (Dali::DaliException e) {
14246       {
14247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14248       };
14249     } catch (...) {
14250       {
14251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14252       };
14253     }
14254   }
14255
14256   jresult = result;
14257   return jresult;
14258 }
14259
14260
14261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14262   unsigned int jresult ;
14263   unsigned int arg1 ;
14264   unsigned int result;
14265
14266   arg1 = (unsigned int)jarg1;
14267   {
14268     try {
14269       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14270     } catch (std::out_of_range& e) {
14271       {
14272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14273       };
14274     } catch (std::exception& e) {
14275       {
14276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14277       };
14278     } catch (Dali::DaliException e) {
14279       {
14280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14281       };
14282     } catch (...) {
14283       {
14284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14285       };
14286     }
14287   }
14288
14289   jresult = result;
14290   return jresult;
14291 }
14292
14293
14294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14295   unsigned int jresult ;
14296   unsigned int arg1 ;
14297   bool result;
14298
14299   arg1 = (unsigned int)jarg1;
14300   {
14301     try {
14302       result = (bool)Dali::IsPowerOfTwo(arg1);
14303     } catch (std::out_of_range& e) {
14304       {
14305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14306       };
14307     } catch (std::exception& e) {
14308       {
14309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14310       };
14311     } catch (Dali::DaliException e) {
14312       {
14313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14314       };
14315     } catch (...) {
14316       {
14317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14318       };
14319     }
14320   }
14321
14322   jresult = result;
14323   return jresult;
14324 }
14325
14326
14327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14328   float jresult ;
14329   float arg1 ;
14330   float arg2 ;
14331   float result;
14332
14333   arg1 = (float)jarg1;
14334   arg2 = (float)jarg2;
14335   {
14336     try {
14337       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14338     } catch (std::out_of_range& e) {
14339       {
14340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14341       };
14342     } catch (std::exception& e) {
14343       {
14344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14345       };
14346     } catch (Dali::DaliException e) {
14347       {
14348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14349       };
14350     } catch (...) {
14351       {
14352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14353       };
14354     }
14355   }
14356
14357   jresult = result;
14358   return jresult;
14359 }
14360
14361
14362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14363   unsigned int jresult ;
14364   float arg1 ;
14365   bool result;
14366
14367   arg1 = (float)jarg1;
14368   {
14369     try {
14370       result = (bool)Dali::EqualsZero(arg1);
14371     } catch (std::out_of_range& e) {
14372       {
14373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14374       };
14375     } catch (std::exception& e) {
14376       {
14377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14378       };
14379     } catch (Dali::DaliException e) {
14380       {
14381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14382       };
14383     } catch (...) {
14384       {
14385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14386       };
14387     }
14388   }
14389
14390   jresult = result;
14391   return jresult;
14392 }
14393
14394
14395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14396   unsigned int jresult ;
14397   float arg1 ;
14398   float arg2 ;
14399   bool result;
14400
14401   arg1 = (float)jarg1;
14402   arg2 = (float)jarg2;
14403   {
14404     try {
14405       result = (bool)Dali::Equals(arg1,arg2);
14406     } catch (std::out_of_range& e) {
14407       {
14408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14409       };
14410     } catch (std::exception& e) {
14411       {
14412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14413       };
14414     } catch (Dali::DaliException e) {
14415       {
14416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14417       };
14418     } catch (...) {
14419       {
14420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14421       };
14422     }
14423   }
14424
14425   jresult = result;
14426   return jresult;
14427 }
14428
14429
14430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14431   unsigned int jresult ;
14432   float arg1 ;
14433   float arg2 ;
14434   float arg3 ;
14435   bool result;
14436
14437   arg1 = (float)jarg1;
14438   arg2 = (float)jarg2;
14439   arg3 = (float)jarg3;
14440   {
14441     try {
14442       result = (bool)Dali::Equals(arg1,arg2,arg3);
14443     } catch (std::out_of_range& e) {
14444       {
14445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14446       };
14447     } catch (std::exception& e) {
14448       {
14449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14450       };
14451     } catch (Dali::DaliException e) {
14452       {
14453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14454       };
14455     } catch (...) {
14456       {
14457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14458       };
14459     }
14460   }
14461
14462   jresult = result;
14463   return jresult;
14464 }
14465
14466
14467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14468   float jresult ;
14469   float arg1 ;
14470   int arg2 ;
14471   float result;
14472
14473   arg1 = (float)jarg1;
14474   arg2 = (int)jarg2;
14475   {
14476     try {
14477       result = (float)Dali::Round(arg1,arg2);
14478     } catch (std::out_of_range& e) {
14479       {
14480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14481       };
14482     } catch (std::exception& e) {
14483       {
14484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14485       };
14486     } catch (Dali::DaliException e) {
14487       {
14488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14489       };
14490     } catch (...) {
14491       {
14492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14493       };
14494     }
14495   }
14496
14497   jresult = result;
14498   return jresult;
14499 }
14500
14501
14502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14503   float jresult ;
14504   float arg1 ;
14505   float arg2 ;
14506   float arg3 ;
14507   float result;
14508
14509   arg1 = (float)jarg1;
14510   arg2 = (float)jarg2;
14511   arg3 = (float)jarg3;
14512   {
14513     try {
14514       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14515     } catch (std::out_of_range& e) {
14516       {
14517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14518       };
14519     } catch (std::exception& e) {
14520       {
14521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14522       };
14523     } catch (Dali::DaliException e) {
14524       {
14525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14526       };
14527     } catch (...) {
14528       {
14529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14530       };
14531     }
14532   }
14533
14534   jresult = result;
14535   return jresult;
14536 }
14537
14538
14539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14540   float jresult ;
14541   float arg1 ;
14542   float arg2 ;
14543   float arg3 ;
14544   float arg4 ;
14545   float result;
14546
14547   arg1 = (float)jarg1;
14548   arg2 = (float)jarg2;
14549   arg3 = (float)jarg3;
14550   arg4 = (float)jarg4;
14551   {
14552     try {
14553       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14554     } catch (std::out_of_range& e) {
14555       {
14556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14557       };
14558     } catch (std::exception& e) {
14559       {
14560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14561       };
14562     } catch (Dali::DaliException e) {
14563       {
14564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14565       };
14566     } catch (...) {
14567       {
14568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14569       };
14570     }
14571   }
14572
14573   jresult = result;
14574   return jresult;
14575 }
14576
14577
14578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14579   int jresult ;
14580   int result;
14581
14582   result = (int)(int)Dali::Property::INVALID_INDEX;
14583   jresult = result;
14584   return jresult;
14585 }
14586
14587
14588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14589   int jresult ;
14590   int result;
14591
14592   result = (int)(int)Dali::Property::INVALID_KEY;
14593   jresult = result;
14594   return jresult;
14595 }
14596
14597
14598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14599   int jresult ;
14600   int result;
14601
14602   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14603   jresult = result;
14604   return jresult;
14605 }
14606
14607
14608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14609   void * jresult ;
14610   Dali::Handle *arg1 = 0 ;
14611   Dali::Property::Index arg2 ;
14612   Dali::Property *result = 0 ;
14613
14614   arg1 = (Dali::Handle *)jarg1;
14615   if (!arg1) {
14616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14617     return 0;
14618   }
14619   arg2 = (Dali::Property::Index)jarg2;
14620   {
14621     try {
14622       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14623     } catch (std::out_of_range& e) {
14624       {
14625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14626       };
14627     } catch (std::exception& e) {
14628       {
14629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14630       };
14631     } catch (Dali::DaliException e) {
14632       {
14633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14634       };
14635     } catch (...) {
14636       {
14637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14638       };
14639     }
14640   }
14641
14642   jresult = (void *)result;
14643   return jresult;
14644 }
14645
14646
14647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14648   void * jresult ;
14649   Dali::Handle *arg1 = 0 ;
14650   Dali::Property::Index arg2 ;
14651   int arg3 ;
14652   Dali::Property *result = 0 ;
14653
14654   arg1 = (Dali::Handle *)jarg1;
14655   if (!arg1) {
14656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14657     return 0;
14658   }
14659   arg2 = (Dali::Property::Index)jarg2;
14660   arg3 = (int)jarg3;
14661   {
14662     try {
14663       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14664     } catch (std::out_of_range& e) {
14665       {
14666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14667       };
14668     } catch (std::exception& e) {
14669       {
14670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14671       };
14672     } catch (Dali::DaliException e) {
14673       {
14674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14675       };
14676     } catch (...) {
14677       {
14678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14679       };
14680     }
14681   }
14682
14683   jresult = (void *)result;
14684   return jresult;
14685 }
14686
14687
14688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14689   void * jresult ;
14690   Dali::Handle *arg1 = 0 ;
14691   std::string *arg2 = 0 ;
14692   Dali::Property *result = 0 ;
14693
14694   arg1 = (Dali::Handle *)jarg1;
14695   if (!arg1) {
14696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14697     return 0;
14698   }
14699   if (!jarg2) {
14700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14701     return 0;
14702   }
14703   std::string arg2_str(jarg2);
14704   arg2 = &arg2_str;
14705   {
14706     try {
14707       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14708     } catch (std::out_of_range& e) {
14709       {
14710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14711       };
14712     } catch (std::exception& e) {
14713       {
14714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14715       };
14716     } catch (Dali::DaliException e) {
14717       {
14718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14719       };
14720     } catch (...) {
14721       {
14722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14723       };
14724     }
14725   }
14726
14727   jresult = (void *)result;
14728
14729   //argout typemap for const std::string&
14730
14731   return jresult;
14732 }
14733
14734
14735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14736   void * jresult ;
14737   Dali::Handle *arg1 = 0 ;
14738   std::string *arg2 = 0 ;
14739   int arg3 ;
14740   Dali::Property *result = 0 ;
14741
14742   arg1 = (Dali::Handle *)jarg1;
14743   if (!arg1) {
14744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14745     return 0;
14746   }
14747   if (!jarg2) {
14748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14749     return 0;
14750   }
14751   std::string arg2_str(jarg2);
14752   arg2 = &arg2_str;
14753   arg3 = (int)jarg3;
14754   {
14755     try {
14756       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14757     } catch (std::out_of_range& e) {
14758       {
14759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14760       };
14761     } catch (std::exception& e) {
14762       {
14763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14764       };
14765     } catch (Dali::DaliException e) {
14766       {
14767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14768       };
14769     } catch (...) {
14770       {
14771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14772       };
14773     }
14774   }
14775
14776   jresult = (void *)result;
14777
14778   //argout typemap for const std::string&
14779
14780   return jresult;
14781 }
14782
14783
14784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14785   Dali::Property *arg1 = (Dali::Property *) 0 ;
14786
14787   arg1 = (Dali::Property *)jarg1;
14788   {
14789     try {
14790       delete arg1;
14791     } catch (std::out_of_range& e) {
14792       {
14793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14794       };
14795     } catch (std::exception& e) {
14796       {
14797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14798       };
14799     } catch (Dali::DaliException e) {
14800       {
14801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14802       };
14803     } catch (...) {
14804       {
14805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14806       };
14807     }
14808   }
14809
14810 }
14811
14812
14813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14814   Dali::Property *arg1 = (Dali::Property *) 0 ;
14815   Dali::Handle *arg2 = 0 ;
14816
14817   arg1 = (Dali::Property *)jarg1;
14818   arg2 = (Dali::Handle *)jarg2;
14819   if (!arg2) {
14820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14821     return ;
14822   }
14823   if (arg1) (arg1)->object = *arg2;
14824 }
14825
14826
14827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14828   void * jresult ;
14829   Dali::Property *arg1 = (Dali::Property *) 0 ;
14830   Dali::Handle *result = 0 ;
14831
14832   arg1 = (Dali::Property *)jarg1;
14833   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14834   jresult = (void *)result;
14835   return jresult;
14836 }
14837
14838
14839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14840   Dali::Property *arg1 = (Dali::Property *) 0 ;
14841   Dali::Property::Index arg2 ;
14842
14843   arg1 = (Dali::Property *)jarg1;
14844   arg2 = (Dali::Property::Index)jarg2;
14845   if (arg1) (arg1)->propertyIndex = arg2;
14846 }
14847
14848
14849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14850   int jresult ;
14851   Dali::Property *arg1 = (Dali::Property *) 0 ;
14852   Dali::Property::Index result;
14853
14854   arg1 = (Dali::Property *)jarg1;
14855   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14856   jresult = result;
14857   return jresult;
14858 }
14859
14860
14861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14862   Dali::Property *arg1 = (Dali::Property *) 0 ;
14863   int arg2 ;
14864
14865   arg1 = (Dali::Property *)jarg1;
14866   arg2 = (int)jarg2;
14867   if (arg1) (arg1)->componentIndex = arg2;
14868 }
14869
14870
14871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14872   int jresult ;
14873   Dali::Property *arg1 = (Dali::Property *) 0 ;
14874   int result;
14875
14876   arg1 = (Dali::Property *)jarg1;
14877   result = (int) ((arg1)->componentIndex);
14878   jresult = result;
14879   return jresult;
14880 }
14881
14882
14883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14884   void * jresult ;
14885   Dali::Property::Array *result = 0 ;
14886
14887   {
14888     try {
14889       result = (Dali::Property::Array *)new Dali::Property::Array();
14890     } catch (std::out_of_range& e) {
14891       {
14892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14893       };
14894     } catch (std::exception& e) {
14895       {
14896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14897       };
14898     } catch (Dali::DaliException e) {
14899       {
14900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14901       };
14902     } catch (...) {
14903       {
14904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14905       };
14906     }
14907   }
14908
14909   jresult = (void *)result;
14910   return jresult;
14911 }
14912
14913
14914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14915   void * jresult ;
14916   Dali::Property::Array *arg1 = 0 ;
14917   Dali::Property::Array *result = 0 ;
14918
14919   arg1 = (Dali::Property::Array *)jarg1;
14920   if (!arg1) {
14921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14922     return 0;
14923   }
14924   {
14925     try {
14926       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14927     } catch (std::out_of_range& e) {
14928       {
14929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14930       };
14931     } catch (std::exception& e) {
14932       {
14933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14934       };
14935     } catch (Dali::DaliException e) {
14936       {
14937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14938       };
14939     } catch (...) {
14940       {
14941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14942       };
14943     }
14944   }
14945
14946   jresult = (void *)result;
14947   return jresult;
14948 }
14949
14950
14951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14952   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14953
14954   arg1 = (Dali::Property::Array *)jarg1;
14955   {
14956     try {
14957       delete arg1;
14958     } catch (std::out_of_range& e) {
14959       {
14960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14961       };
14962     } catch (std::exception& e) {
14963       {
14964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14965       };
14966     } catch (Dali::DaliException e) {
14967       {
14968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14969       };
14970     } catch (...) {
14971       {
14972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14973       };
14974     }
14975   }
14976
14977 }
14978
14979
14980 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14981   unsigned long jresult ;
14982   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14983   Dali::Property::Array::SizeType result;
14984
14985   arg1 = (Dali::Property::Array *)jarg1;
14986   {
14987     try {
14988       result = ((Dali::Property::Array const *)arg1)->Size();
14989     } catch (std::out_of_range& e) {
14990       {
14991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14992       };
14993     } catch (std::exception& e) {
14994       {
14995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14996       };
14997     } catch (Dali::DaliException e) {
14998       {
14999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15000       };
15001     } catch (...) {
15002       {
15003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15004       };
15005     }
15006   }
15007
15008   jresult = (unsigned long)result;
15009   return jresult;
15010 }
15011
15012
15013 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15014   unsigned long jresult ;
15015   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15016   Dali::Property::Array::SizeType result;
15017
15018   arg1 = (Dali::Property::Array *)jarg1;
15019   {
15020     try {
15021       result = ((Dali::Property::Array const *)arg1)->Count();
15022     } catch (std::out_of_range& e) {
15023       {
15024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15025       };
15026     } catch (std::exception& e) {
15027       {
15028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15029       };
15030     } catch (Dali::DaliException e) {
15031       {
15032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15033       };
15034     } catch (...) {
15035       {
15036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15037       };
15038     }
15039   }
15040
15041   jresult = (unsigned long)result;
15042   return jresult;
15043 }
15044
15045
15046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15047   unsigned int jresult ;
15048   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15049   bool result;
15050
15051   arg1 = (Dali::Property::Array *)jarg1;
15052   {
15053     try {
15054       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15055     } catch (std::out_of_range& e) {
15056       {
15057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15058       };
15059     } catch (std::exception& e) {
15060       {
15061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15062       };
15063     } catch (Dali::DaliException e) {
15064       {
15065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15066       };
15067     } catch (...) {
15068       {
15069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15070       };
15071     }
15072   }
15073
15074   jresult = result;
15075   return jresult;
15076 }
15077
15078
15079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15080   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15081
15082   arg1 = (Dali::Property::Array *)jarg1;
15083   {
15084     try {
15085       (arg1)->Clear();
15086     } catch (std::out_of_range& e) {
15087       {
15088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15089       };
15090     } catch (std::exception& e) {
15091       {
15092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15093       };
15094     } catch (Dali::DaliException e) {
15095       {
15096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15097       };
15098     } catch (...) {
15099       {
15100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15101       };
15102     }
15103   }
15104
15105 }
15106
15107
15108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15109   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15110   Dali::Property::Array::SizeType arg2 ;
15111
15112   arg1 = (Dali::Property::Array *)jarg1;
15113   arg2 = (Dali::Property::Array::SizeType)jarg2;
15114   {
15115     try {
15116       (arg1)->Reserve(arg2);
15117     } catch (std::out_of_range& e) {
15118       {
15119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15120       };
15121     } catch (std::exception& e) {
15122       {
15123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15124       };
15125     } catch (Dali::DaliException e) {
15126       {
15127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15128       };
15129     } catch (...) {
15130       {
15131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15132       };
15133     }
15134   }
15135
15136 }
15137
15138
15139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15140   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15141   Dali::Property::Array::SizeType arg2 ;
15142
15143   arg1 = (Dali::Property::Array *)jarg1;
15144   arg2 = (Dali::Property::Array::SizeType)jarg2;
15145   {
15146     try {
15147       (arg1)->Resize(arg2);
15148     } catch (std::out_of_range& e) {
15149       {
15150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15151       };
15152     } catch (std::exception& e) {
15153       {
15154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15155       };
15156     } catch (Dali::DaliException e) {
15157       {
15158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15159       };
15160     } catch (...) {
15161       {
15162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15163       };
15164     }
15165   }
15166
15167 }
15168
15169
15170 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15171   unsigned long jresult ;
15172   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15173   Dali::Property::Array::SizeType result;
15174
15175   arg1 = (Dali::Property::Array *)jarg1;
15176   {
15177     try {
15178       result = (arg1)->Capacity();
15179     } catch (std::out_of_range& e) {
15180       {
15181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15182       };
15183     } catch (std::exception& e) {
15184       {
15185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15186       };
15187     } catch (Dali::DaliException e) {
15188       {
15189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15190       };
15191     } catch (...) {
15192       {
15193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15194       };
15195     }
15196   }
15197
15198   jresult = (unsigned long)result;
15199   return jresult;
15200 }
15201
15202
15203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15204   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15205   Dali::Property::Value *arg2 = 0 ;
15206
15207   arg1 = (Dali::Property::Array *)jarg1;
15208   arg2 = (Dali::Property::Value *)jarg2;
15209   if (!arg2) {
15210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15211     return ;
15212   }
15213   {
15214     try {
15215       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15216     } catch (std::out_of_range& e) {
15217       {
15218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15219       };
15220     } catch (std::exception& e) {
15221       {
15222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15223       };
15224     } catch (Dali::DaliException e) {
15225       {
15226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15227       };
15228     } catch (...) {
15229       {
15230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15231       };
15232     }
15233   }
15234
15235 }
15236
15237
15238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15239   void * jresult ;
15240   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15241   Dali::Property::Value *arg2 = 0 ;
15242   Dali::Property::Array *result = 0 ;
15243
15244   arg1 = (Dali::Property::Array *)jarg1;
15245   arg2 = (Dali::Property::Value *)jarg2;
15246   if (!arg2) {
15247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15248     return 0;
15249   }
15250   {
15251     try {
15252       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15253     } catch (std::out_of_range& e) {
15254       {
15255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15256       };
15257     } catch (std::exception& e) {
15258       {
15259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15260       };
15261     } catch (Dali::DaliException e) {
15262       {
15263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15264       };
15265     } catch (...) {
15266       {
15267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15268       };
15269     }
15270   }
15271
15272   jresult = (void *)result;
15273   return jresult;
15274 }
15275
15276
15277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15278   void * jresult ;
15279   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15280   Dali::Property::Array::SizeType arg2 ;
15281   Dali::Property::Value *result = 0 ;
15282
15283   arg1 = (Dali::Property::Array *)jarg1;
15284   arg2 = (Dali::Property::Array::SizeType)jarg2;
15285   {
15286     try {
15287       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15288     } catch (std::out_of_range& e) {
15289       {
15290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15291       };
15292     } catch (std::exception& e) {
15293       {
15294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15295       };
15296     } catch (Dali::DaliException e) {
15297       {
15298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15299       };
15300     } catch (...) {
15301       {
15302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15303       };
15304     }
15305   }
15306
15307   jresult = (void *)result;
15308   return jresult;
15309 }
15310
15311
15312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15313   void * jresult ;
15314   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15315   Dali::Property::Array::SizeType arg2 ;
15316   Dali::Property::Value *result = 0 ;
15317
15318   arg1 = (Dali::Property::Array *)jarg1;
15319   arg2 = (Dali::Property::Array::SizeType)jarg2;
15320   {
15321     try {
15322       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15323     } catch (std::out_of_range& e) {
15324       {
15325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15326       };
15327     } catch (std::exception& e) {
15328       {
15329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15330       };
15331     } catch (Dali::DaliException e) {
15332       {
15333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15334       };
15335     } catch (...) {
15336       {
15337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15338       };
15339     }
15340   }
15341
15342   jresult = (void *)result;
15343   return jresult;
15344 }
15345
15346
15347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15348   void * jresult ;
15349   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15350   Dali::Property::Array *arg2 = 0 ;
15351   Dali::Property::Array *result = 0 ;
15352
15353   arg1 = (Dali::Property::Array *)jarg1;
15354   arg2 = (Dali::Property::Array *)jarg2;
15355   if (!arg2) {
15356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15357     return 0;
15358   }
15359   {
15360     try {
15361       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15362     } catch (std::out_of_range& e) {
15363       {
15364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15365       };
15366     } catch (std::exception& e) {
15367       {
15368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15369       };
15370     } catch (Dali::DaliException e) {
15371       {
15372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15373       };
15374     } catch (...) {
15375       {
15376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15377       };
15378     }
15379   }
15380
15381   jresult = (void *)result;
15382   return jresult;
15383 }
15384
15385
15386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15387   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15388   enum Dali::Property::Key::Type arg2 ;
15389
15390   arg1 = (Dali::Property::Key *)jarg1;
15391   arg2 = (enum Dali::Property::Key::Type)jarg2;
15392   if (arg1) (arg1)->type = arg2;
15393 }
15394
15395
15396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15397   int jresult ;
15398   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15399   enum Dali::Property::Key::Type result;
15400
15401   arg1 = (Dali::Property::Key *)jarg1;
15402   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15403   jresult = (int)result;
15404   return jresult;
15405 }
15406
15407
15408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15409   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15410   Dali::Property::Index arg2 ;
15411
15412   arg1 = (Dali::Property::Key *)jarg1;
15413   arg2 = (Dali::Property::Index)jarg2;
15414   if (arg1) (arg1)->indexKey = arg2;
15415 }
15416
15417
15418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15419   int jresult ;
15420   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15421   Dali::Property::Index result;
15422
15423   arg1 = (Dali::Property::Key *)jarg1;
15424   result = (Dali::Property::Index) ((arg1)->indexKey);
15425   jresult = result;
15426   return jresult;
15427 }
15428
15429
15430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15431   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15432   std::string *arg2 = 0 ;
15433
15434   arg1 = (Dali::Property::Key *)jarg1;
15435   if (!jarg2) {
15436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15437     return ;
15438   }
15439   std::string arg2_str(jarg2);
15440   arg2 = &arg2_str;
15441   if (arg1) (arg1)->stringKey = *arg2;
15442
15443   //argout typemap for const std::string&
15444
15445 }
15446
15447
15448 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15449   char * jresult ;
15450   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15451   std::string *result = 0 ;
15452
15453   arg1 = (Dali::Property::Key *)jarg1;
15454   result = (std::string *) & ((arg1)->stringKey);
15455   jresult = SWIG_csharp_string_callback(result->c_str());
15456   return jresult;
15457 }
15458
15459
15460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15461   void * jresult ;
15462   std::string *arg1 = 0 ;
15463   Dali::Property::Key *result = 0 ;
15464
15465   if (!jarg1) {
15466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15467     return 0;
15468   }
15469   std::string arg1_str(jarg1);
15470   arg1 = &arg1_str;
15471   {
15472     try {
15473       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15474     } catch (std::out_of_range& e) {
15475       {
15476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15477       };
15478     } catch (std::exception& e) {
15479       {
15480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15481       };
15482     } catch (Dali::DaliException e) {
15483       {
15484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15485       };
15486     } catch (...) {
15487       {
15488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15489       };
15490     }
15491   }
15492
15493   jresult = (void *)result;
15494
15495   //argout typemap for const std::string&
15496
15497   return jresult;
15498 }
15499
15500
15501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15502   void * jresult ;
15503   Dali::Property::Index arg1 ;
15504   Dali::Property::Key *result = 0 ;
15505
15506   arg1 = (Dali::Property::Index)jarg1;
15507   {
15508     try {
15509       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15510     } catch (std::out_of_range& e) {
15511       {
15512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15513       };
15514     } catch (std::exception& e) {
15515       {
15516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15517       };
15518     } catch (Dali::DaliException e) {
15519       {
15520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15521       };
15522     } catch (...) {
15523       {
15524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15525       };
15526     }
15527   }
15528
15529   jresult = (void *)result;
15530   return jresult;
15531 }
15532
15533
15534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15535   unsigned int jresult ;
15536   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15537   std::string *arg2 = 0 ;
15538   bool result;
15539
15540   arg1 = (Dali::Property::Key *)jarg1;
15541   if (!jarg2) {
15542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15543     return 0;
15544   }
15545   std::string arg2_str(jarg2);
15546   arg2 = &arg2_str;
15547   {
15548     try {
15549       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15550     } catch (std::out_of_range& e) {
15551       {
15552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15553       };
15554     } catch (std::exception& e) {
15555       {
15556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15557       };
15558     } catch (Dali::DaliException e) {
15559       {
15560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15561       };
15562     } catch (...) {
15563       {
15564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15565       };
15566     }
15567   }
15568
15569   jresult = result;
15570
15571   //argout typemap for const std::string&
15572
15573   return jresult;
15574 }
15575
15576
15577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15578   unsigned int jresult ;
15579   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15580   Dali::Property::Index arg2 ;
15581   bool result;
15582
15583   arg1 = (Dali::Property::Key *)jarg1;
15584   arg2 = (Dali::Property::Index)jarg2;
15585   {
15586     try {
15587       result = (bool)(arg1)->operator ==(arg2);
15588     } catch (std::out_of_range& e) {
15589       {
15590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15591       };
15592     } catch (std::exception& e) {
15593       {
15594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15595       };
15596     } catch (Dali::DaliException e) {
15597       {
15598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15599       };
15600     } catch (...) {
15601       {
15602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15603       };
15604     }
15605   }
15606
15607   jresult = result;
15608   return jresult;
15609 }
15610
15611
15612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15613   unsigned int jresult ;
15614   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15615   Dali::Property::Key *arg2 = 0 ;
15616   bool result;
15617
15618   arg1 = (Dali::Property::Key *)jarg1;
15619   arg2 = (Dali::Property::Key *)jarg2;
15620   if (!arg2) {
15621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15622     return 0;
15623   }
15624   {
15625     try {
15626       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15627     } catch (std::out_of_range& e) {
15628       {
15629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15630       };
15631     } catch (std::exception& e) {
15632       {
15633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15634       };
15635     } catch (Dali::DaliException e) {
15636       {
15637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15638       };
15639     } catch (...) {
15640       {
15641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15642       };
15643     }
15644   }
15645
15646   jresult = result;
15647   return jresult;
15648 }
15649
15650
15651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15652   unsigned int jresult ;
15653   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15654   std::string *arg2 = 0 ;
15655   bool result;
15656
15657   arg1 = (Dali::Property::Key *)jarg1;
15658   if (!jarg2) {
15659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15660     return 0;
15661   }
15662   std::string arg2_str(jarg2);
15663   arg2 = &arg2_str;
15664   {
15665     try {
15666       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15667     } catch (std::out_of_range& e) {
15668       {
15669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15670       };
15671     } catch (std::exception& e) {
15672       {
15673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15674       };
15675     } catch (Dali::DaliException e) {
15676       {
15677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15678       };
15679     } catch (...) {
15680       {
15681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15682       };
15683     }
15684   }
15685
15686   jresult = result;
15687
15688   //argout typemap for const std::string&
15689
15690   return jresult;
15691 }
15692
15693
15694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15695   unsigned int jresult ;
15696   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15697   Dali::Property::Index arg2 ;
15698   bool result;
15699
15700   arg1 = (Dali::Property::Key *)jarg1;
15701   arg2 = (Dali::Property::Index)jarg2;
15702   {
15703     try {
15704       result = (bool)(arg1)->operator !=(arg2);
15705     } catch (std::out_of_range& e) {
15706       {
15707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15708       };
15709     } catch (std::exception& e) {
15710       {
15711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15712       };
15713     } catch (Dali::DaliException e) {
15714       {
15715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15716       };
15717     } catch (...) {
15718       {
15719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15720       };
15721     }
15722   }
15723
15724   jresult = result;
15725   return jresult;
15726 }
15727
15728
15729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15730   unsigned int jresult ;
15731   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15732   Dali::Property::Key *arg2 = 0 ;
15733   bool result;
15734
15735   arg1 = (Dali::Property::Key *)jarg1;
15736   arg2 = (Dali::Property::Key *)jarg2;
15737   if (!arg2) {
15738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15739     return 0;
15740   }
15741   {
15742     try {
15743       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15744     } catch (std::out_of_range& e) {
15745       {
15746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15747       };
15748     } catch (std::exception& e) {
15749       {
15750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15751       };
15752     } catch (Dali::DaliException e) {
15753       {
15754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15755       };
15756     } catch (...) {
15757       {
15758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15759       };
15760     }
15761   }
15762
15763   jresult = result;
15764   return jresult;
15765 }
15766
15767
15768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15769   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15770
15771   arg1 = (Dali::Property::Key *)jarg1;
15772   {
15773     try {
15774       delete arg1;
15775     } catch (std::out_of_range& e) {
15776       {
15777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15778       };
15779     } catch (std::exception& e) {
15780       {
15781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15782       };
15783     } catch (Dali::DaliException e) {
15784       {
15785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15786       };
15787     } catch (...) {
15788       {
15789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15790       };
15791     }
15792   }
15793
15794 }
15795
15796
15797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15798   void * jresult ;
15799   Dali::Property::Map *result = 0 ;
15800
15801   {
15802     try {
15803       result = (Dali::Property::Map *)new Dali::Property::Map();
15804     } catch (std::out_of_range& e) {
15805       {
15806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15807       };
15808     } catch (std::exception& e) {
15809       {
15810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15811       };
15812     } catch (Dali::DaliException e) {
15813       {
15814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15815       };
15816     } catch (...) {
15817       {
15818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15819       };
15820     }
15821   }
15822
15823   jresult = (void *)result;
15824   return jresult;
15825 }
15826
15827
15828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15829   void * jresult ;
15830   Dali::Property::Map *arg1 = 0 ;
15831   Dali::Property::Map *result = 0 ;
15832
15833   arg1 = (Dali::Property::Map *)jarg1;
15834   if (!arg1) {
15835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15836     return 0;
15837   }
15838   {
15839     try {
15840       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15841     } catch (std::out_of_range& e) {
15842       {
15843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15844       };
15845     } catch (std::exception& e) {
15846       {
15847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15848       };
15849     } catch (Dali::DaliException e) {
15850       {
15851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15852       };
15853     } catch (...) {
15854       {
15855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15856       };
15857     }
15858   }
15859
15860   jresult = (void *)result;
15861   return jresult;
15862 }
15863
15864
15865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15866   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15867
15868   arg1 = (Dali::Property::Map *)jarg1;
15869   {
15870     try {
15871       delete arg1;
15872     } catch (std::out_of_range& e) {
15873       {
15874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15875       };
15876     } catch (std::exception& e) {
15877       {
15878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15879       };
15880     } catch (Dali::DaliException e) {
15881       {
15882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15883       };
15884     } catch (...) {
15885       {
15886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15887       };
15888     }
15889   }
15890
15891 }
15892
15893
15894 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15895   unsigned long jresult ;
15896   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15897   Dali::Property::Map::SizeType result;
15898
15899   arg1 = (Dali::Property::Map *)jarg1;
15900   {
15901     try {
15902       result = ((Dali::Property::Map const *)arg1)->Count();
15903     } catch (std::out_of_range& e) {
15904       {
15905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15906       };
15907     } catch (std::exception& e) {
15908       {
15909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15910       };
15911     } catch (Dali::DaliException e) {
15912       {
15913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15914       };
15915     } catch (...) {
15916       {
15917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15918       };
15919     }
15920   }
15921
15922   jresult = (unsigned long)result;
15923   return jresult;
15924 }
15925
15926
15927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15928   unsigned int jresult ;
15929   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15930   bool result;
15931
15932   arg1 = (Dali::Property::Map *)jarg1;
15933   {
15934     try {
15935       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15936     } catch (std::out_of_range& e) {
15937       {
15938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15939       };
15940     } catch (std::exception& e) {
15941       {
15942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15943       };
15944     } catch (Dali::DaliException e) {
15945       {
15946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15947       };
15948     } catch (...) {
15949       {
15950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15951       };
15952     }
15953   }
15954
15955   jresult = result;
15956   return jresult;
15957 }
15958
15959
15960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15961   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15962   char *arg2 = (char *) 0 ;
15963   Dali::Property::Value *arg3 = 0 ;
15964
15965   arg1 = (Dali::Property::Map *)jarg1;
15966   arg2 = (char *)jarg2;
15967   arg3 = (Dali::Property::Value *)jarg3;
15968   if (!arg3) {
15969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15970     return ;
15971   }
15972   {
15973     try {
15974       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15975     } catch (std::out_of_range& e) {
15976       {
15977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15978       };
15979     } catch (std::exception& e) {
15980       {
15981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15982       };
15983     } catch (Dali::DaliException e) {
15984       {
15985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15986       };
15987     } catch (...) {
15988       {
15989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15990       };
15991     }
15992   }
15993
15994 }
15995
15996
15997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15998   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15999   Dali::Property::Index arg2 ;
16000   Dali::Property::Value *arg3 = 0 ;
16001
16002   arg1 = (Dali::Property::Map *)jarg1;
16003   arg2 = (Dali::Property::Index)jarg2;
16004   arg3 = (Dali::Property::Value *)jarg3;
16005   if (!arg3) {
16006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16007     return ;
16008   }
16009   {
16010     try {
16011       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16012     } catch (std::out_of_range& e) {
16013       {
16014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16015       };
16016     } catch (std::exception& e) {
16017       {
16018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16019       };
16020     } catch (Dali::DaliException e) {
16021       {
16022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16023       };
16024     } catch (...) {
16025       {
16026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16027       };
16028     }
16029   }
16030
16031 }
16032
16033
16034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16035   void * jresult ;
16036   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16037   char *arg2 = (char *) 0 ;
16038   Dali::Property::Value *arg3 = 0 ;
16039   Dali::Property::Map *result = 0 ;
16040
16041   arg1 = (Dali::Property::Map *)jarg1;
16042   arg2 = (char *)jarg2;
16043   arg3 = (Dali::Property::Value *)jarg3;
16044   if (!arg3) {
16045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16046     return 0;
16047   }
16048   {
16049     try {
16050       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16051     } catch (std::out_of_range& e) {
16052       {
16053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16054       };
16055     } catch (std::exception& e) {
16056       {
16057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16058       };
16059     } catch (Dali::DaliException e) {
16060       {
16061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16062       };
16063     } catch (...) {
16064       {
16065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16066       };
16067     }
16068   }
16069
16070   jresult = (void *)result;
16071   return jresult;
16072 }
16073
16074
16075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16076   void * jresult ;
16077   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16078   Dali::Property::Index arg2 ;
16079   Dali::Property::Value *arg3 = 0 ;
16080   Dali::Property::Map *result = 0 ;
16081
16082   arg1 = (Dali::Property::Map *)jarg1;
16083   arg2 = (Dali::Property::Index)jarg2;
16084   arg3 = (Dali::Property::Value *)jarg3;
16085   if (!arg3) {
16086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16087     return 0;
16088   }
16089   {
16090     try {
16091       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16092     } catch (std::out_of_range& e) {
16093       {
16094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16095       };
16096     } catch (std::exception& e) {
16097       {
16098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16099       };
16100     } catch (Dali::DaliException e) {
16101       {
16102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16103       };
16104     } catch (...) {
16105       {
16106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16107       };
16108     }
16109   }
16110
16111   jresult = (void *)result;
16112   return jresult;
16113 }
16114
16115
16116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16117   void * jresult ;
16118   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16119   Dali::Property::Map::SizeType arg2 ;
16120   Dali::Property::Value *result = 0 ;
16121
16122   arg1 = (Dali::Property::Map *)jarg1;
16123   arg2 = (Dali::Property::Map::SizeType)jarg2;
16124   {
16125     try {
16126       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16127     } catch (std::out_of_range& e) {
16128       {
16129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16130       };
16131     } catch (std::exception& e) {
16132       {
16133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16134       };
16135     } catch (Dali::DaliException e) {
16136       {
16137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16138       };
16139     } catch (...) {
16140       {
16141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16142       };
16143     }
16144   }
16145
16146   jresult = (void *)result;
16147   return jresult;
16148 }
16149
16150
16151 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16152   char * jresult ;
16153   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16154   Dali::Property::Map::SizeType arg2 ;
16155   std::string *result = 0 ;
16156
16157   arg1 = (Dali::Property::Map *)jarg1;
16158   arg2 = (Dali::Property::Map::SizeType)jarg2;
16159   {
16160     try {
16161       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16162     } catch (std::out_of_range& e) {
16163       {
16164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16165       };
16166     } catch (std::exception& e) {
16167       {
16168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16169       };
16170     } catch (Dali::DaliException e) {
16171       {
16172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16173       };
16174     } catch (...) {
16175       {
16176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16177       };
16178     }
16179   }
16180
16181   jresult = SWIG_csharp_string_callback(result->c_str());
16182   return jresult;
16183 }
16184
16185
16186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16187   void * jresult ;
16188   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16189   Dali::Property::Map::SizeType arg2 ;
16190   SwigValueWrapper< Dali::Property::Key > result;
16191
16192   arg1 = (Dali::Property::Map *)jarg1;
16193   arg2 = (Dali::Property::Map::SizeType)jarg2;
16194   {
16195     try {
16196       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16197     } catch (std::out_of_range& e) {
16198       {
16199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16200       };
16201     } catch (std::exception& e) {
16202       {
16203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16204       };
16205     } catch (Dali::DaliException e) {
16206       {
16207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16208       };
16209     } catch (...) {
16210       {
16211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16212       };
16213     }
16214   }
16215
16216   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16217   return jresult;
16218 }
16219
16220
16221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16222   void * jresult ;
16223   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16224   Dali::Property::Map::SizeType arg2 ;
16225   StringValuePair *result = 0 ;
16226
16227   arg1 = (Dali::Property::Map *)jarg1;
16228   arg2 = (Dali::Property::Map::SizeType)jarg2;
16229   {
16230     try {
16231       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16232     } catch (std::out_of_range& e) {
16233       {
16234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16235       };
16236     } catch (std::exception& e) {
16237       {
16238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16239       };
16240     } catch (Dali::DaliException e) {
16241       {
16242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16243       };
16244     } catch (...) {
16245       {
16246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16247       };
16248     }
16249   }
16250
16251   jresult = (void *)result;
16252   return jresult;
16253 }
16254
16255
16256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16257   void * jresult ;
16258   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16259   char *arg2 = (char *) 0 ;
16260   Dali::Property::Value *result = 0 ;
16261
16262   arg1 = (Dali::Property::Map *)jarg1;
16263   arg2 = (char *)jarg2;
16264   {
16265     try {
16266       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16267     } catch (std::out_of_range& e) {
16268       {
16269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16270       };
16271     } catch (std::exception& e) {
16272       {
16273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16274       };
16275     } catch (Dali::DaliException e) {
16276       {
16277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16278       };
16279     } catch (...) {
16280       {
16281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16282       };
16283     }
16284   }
16285
16286   jresult = (void *)result;
16287   return jresult;
16288 }
16289
16290
16291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16292   void * jresult ;
16293   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16294   Dali::Property::Index arg2 ;
16295   Dali::Property::Value *result = 0 ;
16296
16297   arg1 = (Dali::Property::Map *)jarg1;
16298   arg2 = (Dali::Property::Index)jarg2;
16299   {
16300     try {
16301       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16302     } catch (std::out_of_range& e) {
16303       {
16304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16305       };
16306     } catch (std::exception& e) {
16307       {
16308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16309       };
16310     } catch (Dali::DaliException e) {
16311       {
16312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16313       };
16314     } catch (...) {
16315       {
16316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16317       };
16318     }
16319   }
16320
16321   jresult = (void *)result;
16322   return jresult;
16323 }
16324
16325
16326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16327   void * jresult ;
16328   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16329   Dali::Property::Index arg2 ;
16330   std::string *arg3 = 0 ;
16331   Dali::Property::Value *result = 0 ;
16332
16333   arg1 = (Dali::Property::Map *)jarg1;
16334   arg2 = (Dali::Property::Index)jarg2;
16335   if (!jarg3) {
16336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16337     return 0;
16338   }
16339   std::string arg3_str(jarg3);
16340   arg3 = &arg3_str;
16341   {
16342     try {
16343       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16344     } catch (std::out_of_range& e) {
16345       {
16346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16347       };
16348     } catch (std::exception& e) {
16349       {
16350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16351       };
16352     } catch (Dali::DaliException e) {
16353       {
16354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16355       };
16356     } catch (...) {
16357       {
16358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16359       };
16360     }
16361   }
16362
16363   jresult = (void *)result;
16364
16365   //argout typemap for const std::string&
16366
16367   return jresult;
16368 }
16369
16370
16371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16372   void * jresult ;
16373   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16374   std::string *arg2 = 0 ;
16375   Dali::Property::Type arg3 ;
16376   Dali::Property::Value *result = 0 ;
16377
16378   arg1 = (Dali::Property::Map *)jarg1;
16379   if (!jarg2) {
16380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16381     return 0;
16382   }
16383   std::string arg2_str(jarg2);
16384   arg2 = &arg2_str;
16385   arg3 = (Dali::Property::Type)jarg3;
16386   {
16387     try {
16388       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16389     } catch (std::out_of_range& e) {
16390       {
16391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16392       };
16393     } catch (std::exception& e) {
16394       {
16395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16396       };
16397     } catch (Dali::DaliException e) {
16398       {
16399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16400       };
16401     } catch (...) {
16402       {
16403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16404       };
16405     }
16406   }
16407
16408   jresult = (void *)result;
16409
16410   //argout typemap for const std::string&
16411
16412   return jresult;
16413 }
16414
16415
16416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16417   void * jresult ;
16418   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16419   Dali::Property::Index arg2 ;
16420   Dali::Property::Type arg3 ;
16421   Dali::Property::Value *result = 0 ;
16422
16423   arg1 = (Dali::Property::Map *)jarg1;
16424   arg2 = (Dali::Property::Index)jarg2;
16425   arg3 = (Dali::Property::Type)jarg3;
16426   {
16427     try {
16428       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16429     } catch (std::out_of_range& e) {
16430       {
16431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16432       };
16433     } catch (std::exception& e) {
16434       {
16435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16436       };
16437     } catch (Dali::DaliException e) {
16438       {
16439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16440       };
16441     } catch (...) {
16442       {
16443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16444       };
16445     }
16446   }
16447
16448   jresult = (void *)result;
16449   return jresult;
16450 }
16451
16452
16453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16454   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16455
16456   arg1 = (Dali::Property::Map *)jarg1;
16457   {
16458     try {
16459       (arg1)->Clear();
16460     } catch (std::out_of_range& e) {
16461       {
16462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16463       };
16464     } catch (std::exception& e) {
16465       {
16466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16467       };
16468     } catch (Dali::DaliException e) {
16469       {
16470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16471       };
16472     } catch (...) {
16473       {
16474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16475       };
16476     }
16477   }
16478
16479 }
16480
16481
16482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16483   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16484   Dali::Property::Map *arg2 = 0 ;
16485
16486   arg1 = (Dali::Property::Map *)jarg1;
16487   arg2 = (Dali::Property::Map *)jarg2;
16488   if (!arg2) {
16489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16490     return ;
16491   }
16492   {
16493     try {
16494       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16495     } catch (std::out_of_range& e) {
16496       {
16497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16498       };
16499     } catch (std::exception& e) {
16500       {
16501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16502       };
16503     } catch (Dali::DaliException e) {
16504       {
16505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16506       };
16507     } catch (...) {
16508       {
16509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16510       };
16511     }
16512   }
16513
16514 }
16515
16516
16517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16518   void * jresult ;
16519   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16520   std::string *arg2 = 0 ;
16521   Dali::Property::Value *result = 0 ;
16522
16523   arg1 = (Dali::Property::Map *)jarg1;
16524   if (!jarg2) {
16525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16526     return 0;
16527   }
16528   std::string arg2_str(jarg2);
16529   arg2 = &arg2_str;
16530   {
16531     try {
16532       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16533     } catch (std::out_of_range& e) {
16534       {
16535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16536       };
16537     } catch (std::exception& e) {
16538       {
16539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16540       };
16541     } catch (Dali::DaliException e) {
16542       {
16543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16544       };
16545     } catch (...) {
16546       {
16547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16548       };
16549     }
16550   }
16551
16552   jresult = (void *)result;
16553
16554   //argout typemap for const std::string&
16555
16556   return jresult;
16557 }
16558
16559
16560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16561   void * jresult ;
16562   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16563   Dali::Property::Index arg2 ;
16564   Dali::Property::Value *result = 0 ;
16565
16566   arg1 = (Dali::Property::Map *)jarg1;
16567   arg2 = (Dali::Property::Index)jarg2;
16568   {
16569     try {
16570       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16571     } catch (std::out_of_range& e) {
16572       {
16573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16574       };
16575     } catch (std::exception& e) {
16576       {
16577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16578       };
16579     } catch (Dali::DaliException e) {
16580       {
16581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16582       };
16583     } catch (...) {
16584       {
16585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16586       };
16587     }
16588   }
16589
16590   jresult = (void *)result;
16591   return jresult;
16592 }
16593
16594
16595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16596   void * jresult ;
16597   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16598   Dali::Property::Map *arg2 = 0 ;
16599   Dali::Property::Map *result = 0 ;
16600
16601   arg1 = (Dali::Property::Map *)jarg1;
16602   arg2 = (Dali::Property::Map *)jarg2;
16603   if (!arg2) {
16604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16605     return 0;
16606   }
16607   {
16608     try {
16609       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16610     } catch (std::out_of_range& e) {
16611       {
16612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16613       };
16614     } catch (std::exception& e) {
16615       {
16616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16617       };
16618     } catch (Dali::DaliException e) {
16619       {
16620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16621       };
16622     } catch (...) {
16623       {
16624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16625       };
16626     }
16627   }
16628
16629   jresult = (void *)result;
16630   return jresult;
16631 }
16632
16633
16634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16635
16636   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16637
16638   if (!jarg2) {
16639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16640     return;
16641   }
16642   std::string arg2_str(jarg2);
16643   std::string* arg2 = &arg2_str;
16644
16645   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16646
16647   {
16648     try {
16649       arg1->operator[]((std::string const &)*arg2) = *arg3;
16650     } catch (std::out_of_range& e) {
16651       {
16652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16653       };
16654     } catch (std::exception& e) {
16655       {
16656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16657       };
16658     } catch (Dali::DaliException e) {
16659       {
16660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16661       };
16662     } catch (...) {
16663       {
16664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16665       };
16666     }
16667   }
16668 }
16669
16670
16671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16672
16673   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16674   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16675   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16676
16677   {
16678     try {
16679       arg1->operator[](arg2) = *arg3;
16680     } catch (std::out_of_range& e) {
16681       {
16682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16683       };
16684     } catch (std::exception& e) {
16685       {
16686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16687       };
16688     } catch (Dali::DaliException e) {
16689       {
16690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16691       };
16692     } catch (...) {
16693       {
16694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16695       };
16696     }
16697   }
16698 }
16699
16700
16701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16702   void * jresult ;
16703   Dali::Property::Value *result = 0 ;
16704
16705   {
16706     try {
16707       result = (Dali::Property::Value *)new Dali::Property::Value();
16708     } catch (std::out_of_range& e) {
16709       {
16710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16711       };
16712     } catch (std::exception& e) {
16713       {
16714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16715       };
16716     } catch (Dali::DaliException e) {
16717       {
16718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16719       };
16720     } catch (...) {
16721       {
16722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16723       };
16724     }
16725   }
16726
16727   jresult = (void *)result;
16728   return jresult;
16729 }
16730
16731
16732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16733   void * jresult ;
16734   bool arg1 ;
16735   Dali::Property::Value *result = 0 ;
16736
16737   arg1 = jarg1 ? true : false;
16738   {
16739     try {
16740       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16741     } catch (std::out_of_range& e) {
16742       {
16743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16744       };
16745     } catch (std::exception& e) {
16746       {
16747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16748       };
16749     } catch (Dali::DaliException e) {
16750       {
16751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16752       };
16753     } catch (...) {
16754       {
16755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16756       };
16757     }
16758   }
16759
16760   jresult = (void *)result;
16761   return jresult;
16762 }
16763
16764
16765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16766   void * jresult ;
16767   int arg1 ;
16768   Dali::Property::Value *result = 0 ;
16769
16770   arg1 = (int)jarg1;
16771   {
16772     try {
16773       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16774     } catch (std::out_of_range& e) {
16775       {
16776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16777       };
16778     } catch (std::exception& e) {
16779       {
16780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16781       };
16782     } catch (Dali::DaliException e) {
16783       {
16784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16785       };
16786     } catch (...) {
16787       {
16788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16789       };
16790     }
16791   }
16792
16793   jresult = (void *)result;
16794   return jresult;
16795 }
16796
16797
16798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16799   void * jresult ;
16800   float arg1 ;
16801   Dali::Property::Value *result = 0 ;
16802
16803   arg1 = (float)jarg1;
16804   {
16805     try {
16806       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16807     } catch (std::out_of_range& e) {
16808       {
16809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16810       };
16811     } catch (std::exception& e) {
16812       {
16813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16814       };
16815     } catch (Dali::DaliException e) {
16816       {
16817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16818       };
16819     } catch (...) {
16820       {
16821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16822       };
16823     }
16824   }
16825
16826   jresult = (void *)result;
16827   return jresult;
16828 }
16829
16830
16831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16832   void * jresult ;
16833   Dali::Vector2 *arg1 = 0 ;
16834   Dali::Property::Value *result = 0 ;
16835
16836   arg1 = (Dali::Vector2 *)jarg1;
16837   if (!arg1) {
16838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16839     return 0;
16840   }
16841   {
16842     try {
16843       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16844     } catch (std::out_of_range& e) {
16845       {
16846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16847       };
16848     } catch (std::exception& e) {
16849       {
16850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16851       };
16852     } catch (Dali::DaliException e) {
16853       {
16854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16855       };
16856     } catch (...) {
16857       {
16858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16859       };
16860     }
16861   }
16862
16863   jresult = (void *)result;
16864   return jresult;
16865 }
16866
16867
16868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16869   void * jresult ;
16870   Dali::Vector3 *arg1 = 0 ;
16871   Dali::Property::Value *result = 0 ;
16872
16873   arg1 = (Dali::Vector3 *)jarg1;
16874   if (!arg1) {
16875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16876     return 0;
16877   }
16878   {
16879     try {
16880       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16881     } catch (std::out_of_range& e) {
16882       {
16883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16884       };
16885     } catch (std::exception& e) {
16886       {
16887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16888       };
16889     } catch (Dali::DaliException e) {
16890       {
16891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16892       };
16893     } catch (...) {
16894       {
16895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16896       };
16897     }
16898   }
16899
16900   jresult = (void *)result;
16901   return jresult;
16902 }
16903
16904
16905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16906   void * jresult ;
16907   Dali::Vector4 *arg1 = 0 ;
16908   Dali::Property::Value *result = 0 ;
16909
16910   arg1 = (Dali::Vector4 *)jarg1;
16911   if (!arg1) {
16912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16913     return 0;
16914   }
16915   {
16916     try {
16917       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16918     } catch (std::out_of_range& e) {
16919       {
16920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16921       };
16922     } catch (std::exception& e) {
16923       {
16924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16925       };
16926     } catch (Dali::DaliException e) {
16927       {
16928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16929       };
16930     } catch (...) {
16931       {
16932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16933       };
16934     }
16935   }
16936
16937   jresult = (void *)result;
16938   return jresult;
16939 }
16940
16941
16942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16943   void * jresult ;
16944   Dali::Matrix3 *arg1 = 0 ;
16945   Dali::Property::Value *result = 0 ;
16946
16947   arg1 = (Dali::Matrix3 *)jarg1;
16948   if (!arg1) {
16949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16950     return 0;
16951   }
16952   {
16953     try {
16954       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16955     } catch (std::out_of_range& e) {
16956       {
16957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16958       };
16959     } catch (std::exception& e) {
16960       {
16961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16962       };
16963     } catch (Dali::DaliException e) {
16964       {
16965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16966       };
16967     } catch (...) {
16968       {
16969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16970       };
16971     }
16972   }
16973
16974   jresult = (void *)result;
16975   return jresult;
16976 }
16977
16978
16979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16980   void * jresult ;
16981   Dali::Matrix *arg1 = 0 ;
16982   Dali::Property::Value *result = 0 ;
16983
16984   arg1 = (Dali::Matrix *)jarg1;
16985   if (!arg1) {
16986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16987     return 0;
16988   }
16989   {
16990     try {
16991       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16992     } catch (std::out_of_range& e) {
16993       {
16994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16995       };
16996     } catch (std::exception& e) {
16997       {
16998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16999       };
17000     } catch (Dali::DaliException e) {
17001       {
17002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17003       };
17004     } catch (...) {
17005       {
17006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17007       };
17008     }
17009   }
17010
17011   jresult = (void *)result;
17012   return jresult;
17013 }
17014
17015
17016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
17017   void * jresult ;
17018   Dali::Rect< int > *arg1 = 0 ;
17019   Dali::Property::Value *result = 0 ;
17020
17021   arg1 = (Dali::Rect< int > *)jarg1;
17022   if (!arg1) {
17023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
17024     return 0;
17025   }
17026   {
17027     try {
17028       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
17029     } catch (std::out_of_range& e) {
17030       {
17031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17032       };
17033     } catch (std::exception& e) {
17034       {
17035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17036       };
17037     } catch (Dali::DaliException e) {
17038       {
17039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17040       };
17041     } catch (...) {
17042       {
17043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17044       };
17045     }
17046   }
17047
17048   jresult = (void *)result;
17049   return jresult;
17050 }
17051
17052
17053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17054   void * jresult ;
17055   Dali::AngleAxis *arg1 = 0 ;
17056   Dali::Property::Value *result = 0 ;
17057
17058   arg1 = (Dali::AngleAxis *)jarg1;
17059   if (!arg1) {
17060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17061     return 0;
17062   }
17063   {
17064     try {
17065       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17066     } catch (std::out_of_range& e) {
17067       {
17068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17069       };
17070     } catch (std::exception& e) {
17071       {
17072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17073       };
17074     } catch (Dali::DaliException e) {
17075       {
17076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17077       };
17078     } catch (...) {
17079       {
17080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17081       };
17082     }
17083   }
17084
17085   jresult = (void *)result;
17086   return jresult;
17087 }
17088
17089
17090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17091   void * jresult ;
17092   Dali::Quaternion *arg1 = 0 ;
17093   Dali::Property::Value *result = 0 ;
17094
17095   arg1 = (Dali::Quaternion *)jarg1;
17096   if (!arg1) {
17097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17098     return 0;
17099   }
17100   {
17101     try {
17102       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17103     } catch (std::out_of_range& e) {
17104       {
17105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17106       };
17107     } catch (std::exception& e) {
17108       {
17109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17110       };
17111     } catch (Dali::DaliException e) {
17112       {
17113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17114       };
17115     } catch (...) {
17116       {
17117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17118       };
17119     }
17120   }
17121
17122   jresult = (void *)result;
17123   return jresult;
17124 }
17125
17126
17127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17128   void * jresult ;
17129   std::string *arg1 = 0 ;
17130   Dali::Property::Value *result = 0 ;
17131
17132   if (!jarg1) {
17133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17134     return 0;
17135   }
17136   std::string arg1_str(jarg1);
17137   arg1 = &arg1_str;
17138   {
17139     try {
17140       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17141     } catch (std::out_of_range& e) {
17142       {
17143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17144       };
17145     } catch (std::exception& e) {
17146       {
17147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17148       };
17149     } catch (Dali::DaliException e) {
17150       {
17151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17152       };
17153     } catch (...) {
17154       {
17155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17156       };
17157     }
17158   }
17159
17160   jresult = (void *)result;
17161
17162   //argout typemap for const std::string&
17163
17164   return jresult;
17165 }
17166
17167
17168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17169   void * jresult ;
17170   Dali::Property::Array *arg1 = 0 ;
17171   Dali::Property::Value *result = 0 ;
17172
17173   arg1 = (Dali::Property::Array *)jarg1;
17174   if (!arg1) {
17175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17176     return 0;
17177   }
17178   {
17179     try {
17180       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17181     } catch (std::out_of_range& e) {
17182       {
17183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17184       };
17185     } catch (std::exception& e) {
17186       {
17187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17188       };
17189     } catch (Dali::DaliException e) {
17190       {
17191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17192       };
17193     } catch (...) {
17194       {
17195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17196       };
17197     }
17198   }
17199
17200   jresult = (void *)result;
17201   return jresult;
17202 }
17203
17204
17205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17206   void * jresult ;
17207   Dali::Property::Map *arg1 = 0 ;
17208   Dali::Property::Value *result = 0 ;
17209
17210   arg1 = (Dali::Property::Map *)jarg1;
17211   if (!arg1) {
17212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17213     return 0;
17214   }
17215   {
17216     try {
17217       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17218     } catch (std::out_of_range& e) {
17219       {
17220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17221       };
17222     } catch (std::exception& e) {
17223       {
17224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17225       };
17226     } catch (Dali::DaliException e) {
17227       {
17228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17229       };
17230     } catch (...) {
17231       {
17232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17233       };
17234     }
17235   }
17236
17237   jresult = (void *)result;
17238   return jresult;
17239 }
17240
17241
17242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17243   void * jresult ;
17244   Extents *arg1 = 0 ;
17245   Dali::Property::Value *result = 0 ;
17246
17247   arg1 = (Extents *)jarg1;
17248   if (!arg1) {
17249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17250     return 0;
17251   }
17252   {
17253     try {
17254       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17255     } catch (std::out_of_range& e) {
17256       {
17257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17258       };
17259     } catch (std::exception& e) {
17260       {
17261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17262       };
17263     } catch (...) {
17264       {
17265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17266       };
17267     }
17268   }
17269   jresult = (void *)result;
17270   return jresult;
17271 }
17272
17273
17274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17275   void * jresult ;
17276   Dali::Property::Type arg1 ;
17277   Dali::Property::Value *result = 0 ;
17278
17279   arg1 = (Dali::Property::Type)jarg1;
17280   {
17281     try {
17282       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17283     } catch (std::out_of_range& e) {
17284       {
17285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17286       };
17287     } catch (std::exception& e) {
17288       {
17289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17290       };
17291     } catch (Dali::DaliException e) {
17292       {
17293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17294       };
17295     } catch (...) {
17296       {
17297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17298       };
17299     }
17300   }
17301
17302   jresult = (void *)result;
17303   return jresult;
17304 }
17305
17306
17307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17308   void * jresult ;
17309   Dali::Property::Value *arg1 = 0 ;
17310   Dali::Property::Value *result = 0 ;
17311
17312   arg1 = (Dali::Property::Value *)jarg1;
17313   if (!arg1) {
17314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17315     return 0;
17316   }
17317   {
17318     try {
17319       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17320     } catch (std::out_of_range& e) {
17321       {
17322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17323       };
17324     } catch (std::exception& e) {
17325       {
17326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17327       };
17328     } catch (Dali::DaliException e) {
17329       {
17330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17331       };
17332     } catch (...) {
17333       {
17334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17335       };
17336     }
17337   }
17338
17339   jresult = (void *)result;
17340   return jresult;
17341 }
17342
17343
17344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17345   void * jresult ;
17346   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17347   Dali::Property::Value *arg2 = 0 ;
17348   Dali::Property::Value *result = 0 ;
17349
17350   arg1 = (Dali::Property::Value *)jarg1;
17351   arg2 = (Dali::Property::Value *)jarg2;
17352   if (!arg2) {
17353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17354     return 0;
17355   }
17356   {
17357     try {
17358       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17359     } catch (std::out_of_range& e) {
17360       {
17361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17362       };
17363     } catch (std::exception& e) {
17364       {
17365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17366       };
17367     } catch (Dali::DaliException e) {
17368       {
17369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17370       };
17371     } catch (...) {
17372       {
17373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17374       };
17375     }
17376   }
17377
17378   jresult = (void *)result;
17379   return jresult;
17380 }
17381
17382
17383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17384   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17385
17386   arg1 = (Dali::Property::Value *)jarg1;
17387   {
17388     try {
17389       delete arg1;
17390     } catch (std::out_of_range& e) {
17391       {
17392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17393       };
17394     } catch (std::exception& e) {
17395       {
17396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17397       };
17398     } catch (Dali::DaliException e) {
17399       {
17400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17401       };
17402     } catch (...) {
17403       {
17404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17405       };
17406     }
17407   }
17408
17409 }
17410
17411
17412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17413   int jresult ;
17414   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17415   Dali::Property::Type result;
17416
17417   arg1 = (Dali::Property::Value *)jarg1;
17418   {
17419     try {
17420       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17421     } catch (std::out_of_range& e) {
17422       {
17423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17424       };
17425     } catch (std::exception& e) {
17426       {
17427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17428       };
17429     } catch (Dali::DaliException e) {
17430       {
17431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17432       };
17433     } catch (...) {
17434       {
17435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17436       };
17437     }
17438   }
17439
17440   jresult = (int)result;
17441   return jresult;
17442 }
17443
17444
17445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17446   unsigned int jresult ;
17447   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17448   bool *arg2 = 0 ;
17449   bool result;
17450
17451   arg1 = (Dali::Property::Value *)jarg1;
17452   arg2 = (bool *)jarg2;
17453   {
17454     try {
17455       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17456     } catch (std::out_of_range& e) {
17457       {
17458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17459       };
17460     } catch (std::exception& e) {
17461       {
17462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17463       };
17464     } catch (Dali::DaliException e) {
17465       {
17466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17467       };
17468     } catch (...) {
17469       {
17470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17471       };
17472     }
17473   }
17474
17475   jresult = result;
17476   return jresult;
17477 }
17478
17479
17480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17481   unsigned int jresult ;
17482   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17483   float *arg2 = 0 ;
17484   bool result;
17485
17486   arg1 = (Dali::Property::Value *)jarg1;
17487   arg2 = (float *)jarg2;
17488   {
17489     try {
17490       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17491     } catch (std::out_of_range& e) {
17492       {
17493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17494       };
17495     } catch (std::exception& e) {
17496       {
17497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17498       };
17499     } catch (Dali::DaliException e) {
17500       {
17501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17502       };
17503     } catch (...) {
17504       {
17505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17506       };
17507     }
17508   }
17509
17510   jresult = result;
17511   return jresult;
17512 }
17513
17514
17515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17516   unsigned int jresult ;
17517   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17518   int *arg2 = 0 ;
17519   bool result;
17520
17521   arg1 = (Dali::Property::Value *)jarg1;
17522   arg2 = (int *)jarg2;
17523   {
17524     try {
17525       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17526     } catch (std::out_of_range& e) {
17527       {
17528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17529       };
17530     } catch (std::exception& e) {
17531       {
17532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17533       };
17534     } catch (Dali::DaliException e) {
17535       {
17536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17537       };
17538     } catch (...) {
17539       {
17540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17541       };
17542     }
17543   }
17544
17545   jresult = result;
17546   return jresult;
17547 }
17548
17549
17550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17551   unsigned int jresult ;
17552   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17553   Dali::Rect< int > *arg2 = 0 ;
17554   bool result;
17555
17556   arg1 = (Dali::Property::Value *)jarg1;
17557   arg2 = (Dali::Rect< int > *)jarg2;
17558   if (!arg2) {
17559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17560     return 0;
17561   }
17562   {
17563     try {
17564       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17565     } catch (std::out_of_range& e) {
17566       {
17567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17568       };
17569     } catch (std::exception& e) {
17570       {
17571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17572       };
17573     } catch (Dali::DaliException e) {
17574       {
17575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17576       };
17577     } catch (...) {
17578       {
17579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17580       };
17581     }
17582   }
17583
17584   jresult = result;
17585   return jresult;
17586 }
17587
17588
17589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17590   unsigned int jresult ;
17591   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17592   Dali::Vector2 *arg2 = 0 ;
17593   bool result;
17594
17595   arg1 = (Dali::Property::Value *)jarg1;
17596   arg2 = (Dali::Vector2 *)jarg2;
17597   if (!arg2) {
17598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17599     return 0;
17600   }
17601   {
17602     try {
17603       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17604     } catch (std::out_of_range& e) {
17605       {
17606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17607       };
17608     } catch (std::exception& e) {
17609       {
17610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17611       };
17612     } catch (Dali::DaliException e) {
17613       {
17614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17615       };
17616     } catch (...) {
17617       {
17618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17619       };
17620     }
17621   }
17622
17623   jresult = result;
17624   return jresult;
17625 }
17626
17627
17628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17629   unsigned int jresult ;
17630   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17631   Dali::Vector3 *arg2 = 0 ;
17632   bool result;
17633
17634   arg1 = (Dali::Property::Value *)jarg1;
17635   arg2 = (Dali::Vector3 *)jarg2;
17636   if (!arg2) {
17637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17638     return 0;
17639   }
17640   {
17641     try {
17642       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17643     } catch (std::out_of_range& e) {
17644       {
17645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17646       };
17647     } catch (std::exception& e) {
17648       {
17649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17650       };
17651     } catch (Dali::DaliException e) {
17652       {
17653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17654       };
17655     } catch (...) {
17656       {
17657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17658       };
17659     }
17660   }
17661
17662   jresult = result;
17663   return jresult;
17664 }
17665
17666
17667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17668   unsigned int jresult ;
17669   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17670   Dali::Vector4 *arg2 = 0 ;
17671   bool result;
17672
17673   arg1 = (Dali::Property::Value *)jarg1;
17674   arg2 = (Dali::Vector4 *)jarg2;
17675   if (!arg2) {
17676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17677     return 0;
17678   }
17679   {
17680     try {
17681       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17682     } catch (std::out_of_range& e) {
17683       {
17684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17685       };
17686     } catch (std::exception& e) {
17687       {
17688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17689       };
17690     } catch (Dali::DaliException e) {
17691       {
17692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17693       };
17694     } catch (...) {
17695       {
17696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17697       };
17698     }
17699   }
17700
17701   jresult = result;
17702   return jresult;
17703 }
17704
17705
17706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17707   unsigned int jresult ;
17708   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17709   Dali::Matrix3 *arg2 = 0 ;
17710   bool result;
17711
17712   arg1 = (Dali::Property::Value *)jarg1;
17713   arg2 = (Dali::Matrix3 *)jarg2;
17714   if (!arg2) {
17715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17716     return 0;
17717   }
17718   {
17719     try {
17720       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17721     } catch (std::out_of_range& e) {
17722       {
17723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17724       };
17725     } catch (std::exception& e) {
17726       {
17727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17728       };
17729     } catch (Dali::DaliException e) {
17730       {
17731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17732       };
17733     } catch (...) {
17734       {
17735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17736       };
17737     }
17738   }
17739
17740   jresult = result;
17741   return jresult;
17742 }
17743
17744
17745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17746   unsigned int jresult ;
17747   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17748   Dali::Matrix *arg2 = 0 ;
17749   bool result;
17750
17751   arg1 = (Dali::Property::Value *)jarg1;
17752   arg2 = (Dali::Matrix *)jarg2;
17753   if (!arg2) {
17754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17755     return 0;
17756   }
17757   {
17758     try {
17759       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17760     } catch (std::out_of_range& e) {
17761       {
17762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17763       };
17764     } catch (std::exception& e) {
17765       {
17766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17767       };
17768     } catch (Dali::DaliException e) {
17769       {
17770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17771       };
17772     } catch (...) {
17773       {
17774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17775       };
17776     }
17777   }
17778
17779   jresult = result;
17780   return jresult;
17781 }
17782
17783
17784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17785   unsigned int jresult ;
17786   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17787   Dali::AngleAxis *arg2 = 0 ;
17788   bool result;
17789
17790   arg1 = (Dali::Property::Value *)jarg1;
17791   arg2 = (Dali::AngleAxis *)jarg2;
17792   if (!arg2) {
17793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17794     return 0;
17795   }
17796   {
17797     try {
17798       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17799     } catch (std::out_of_range& e) {
17800       {
17801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17802       };
17803     } catch (std::exception& e) {
17804       {
17805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17806       };
17807     } catch (Dali::DaliException e) {
17808       {
17809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17810       };
17811     } catch (...) {
17812       {
17813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17814       };
17815     }
17816   }
17817
17818   jresult = result;
17819   return jresult;
17820 }
17821
17822
17823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17824   unsigned int jresult ;
17825   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17826   Dali::Quaternion *arg2 = 0 ;
17827   bool result;
17828
17829   arg1 = (Dali::Property::Value *)jarg1;
17830   arg2 = (Dali::Quaternion *)jarg2;
17831   if (!arg2) {
17832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17833     return 0;
17834   }
17835   {
17836     try {
17837       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17838     } catch (std::out_of_range& e) {
17839       {
17840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17841       };
17842     } catch (std::exception& e) {
17843       {
17844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17845       };
17846     } catch (Dali::DaliException e) {
17847       {
17848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17849       };
17850     } catch (...) {
17851       {
17852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17853       };
17854     }
17855   }
17856
17857   jresult = result;
17858   return jresult;
17859 }
17860
17861
17862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17863   unsigned int jresult ;
17864   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17865   std::string *arg2 = 0 ;
17866   bool result;
17867
17868   arg1 = (Dali::Property::Value *)jarg1;
17869
17870   //typemap in
17871   std::string temp;
17872   arg2 = &temp;
17873
17874   {
17875     try {
17876       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17877     } catch (std::out_of_range& e) {
17878       {
17879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17880       };
17881     } catch (std::exception& e) {
17882       {
17883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17884       };
17885     } catch (Dali::DaliException e) {
17886       {
17887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17888       };
17889     } catch (...) {
17890       {
17891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17892       };
17893     }
17894   }
17895
17896   jresult = result;
17897
17898   //Typemap argout in c++ file.
17899   //This will convert c++ string to c# string
17900   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17901
17902   return jresult;
17903 }
17904
17905
17906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17907   unsigned int jresult ;
17908   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17909   Dali::Property::Array *arg2 = 0 ;
17910   bool result;
17911
17912   arg1 = (Dali::Property::Value *)jarg1;
17913   arg2 = (Dali::Property::Array *)jarg2;
17914   if (!arg2) {
17915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17916     return 0;
17917   }
17918   {
17919     try {
17920       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17921     } catch (std::out_of_range& e) {
17922       {
17923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17924       };
17925     } catch (std::exception& e) {
17926       {
17927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17928       };
17929     } catch (Dali::DaliException e) {
17930       {
17931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17932       };
17933     } catch (...) {
17934       {
17935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17936       };
17937     }
17938   }
17939
17940   jresult = result;
17941   return jresult;
17942 }
17943
17944
17945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17946   unsigned int jresult ;
17947   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17948   Dali::Property::Map *arg2 = 0 ;
17949   bool result;
17950
17951   arg1 = (Dali::Property::Value *)jarg1;
17952   arg2 = (Dali::Property::Map *)jarg2;
17953   if (!arg2) {
17954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17955     return 0;
17956   }
17957   {
17958     try {
17959       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17960     } catch (std::out_of_range& e) {
17961       {
17962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17963       };
17964     } catch (std::exception& e) {
17965       {
17966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17967       };
17968     } catch (Dali::DaliException e) {
17969       {
17970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17971       };
17972     } catch (...) {
17973       {
17974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17975       };
17976     }
17977   }
17978
17979   jresult = result;
17980   return jresult;
17981 }
17982
17983
17984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17985   unsigned int jresult ;
17986   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17987   Extents *arg2 = 0 ;
17988   bool result;
17989
17990   arg1 = (Dali::Property::Value *)jarg1;
17991   arg2 = (Extents *)jarg2;
17992   if (!arg2) {
17993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17994     return 0;
17995   }
17996   {
17997     try {
17998       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17999     } catch (std::out_of_range& e) {
18000       {
18001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18002       };
18003     } catch (std::exception& e) {
18004       {
18005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18006       };
18007     } catch (...) {
18008       {
18009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18010       };
18011     }
18012   }
18013   jresult = result;
18014   return jresult;
18015 }
18016
18017
18018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
18019   void * jresult ;
18020   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18021   Dali::Property::Array *result = 0 ;
18022
18023   arg1 = (Dali::Property::Value *)jarg1;
18024   {
18025     try {
18026       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
18027     } catch (std::out_of_range& e) {
18028       {
18029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18030       };
18031     } catch (std::exception& e) {
18032       {
18033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18034       };
18035     } catch (Dali::DaliException e) {
18036       {
18037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18038       };
18039     } catch (...) {
18040       {
18041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18042       };
18043     }
18044   }
18045
18046   jresult = (void *)result;
18047   return jresult;
18048 }
18049
18050
18051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18052   void * jresult ;
18053   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18054   Dali::Property::Map *result = 0 ;
18055
18056   arg1 = (Dali::Property::Value *)jarg1;
18057   {
18058     try {
18059       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18060     } catch (std::out_of_range& e) {
18061       {
18062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18063       };
18064     } catch (std::exception& e) {
18065       {
18066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18067       };
18068     } catch (Dali::DaliException e) {
18069       {
18070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18071       };
18072     } catch (...) {
18073       {
18074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18075       };
18076     }
18077   }
18078
18079   jresult = (void *)result;
18080   return jresult;
18081 }
18082
18083
18084 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18085   char * jresult ;
18086   Dali::Property::Type arg1 ;
18087   char *result = 0 ;
18088
18089   arg1 = (Dali::Property::Type)jarg1;
18090   {
18091     try {
18092       result = (char *)Dali::PropertyTypes::GetName(arg1);
18093     } catch (std::out_of_range& e) {
18094       {
18095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18096       };
18097     } catch (std::exception& e) {
18098       {
18099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18100       };
18101     } catch (Dali::DaliException e) {
18102       {
18103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18104       };
18105     } catch (...) {
18106       {
18107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18108       };
18109     }
18110   }
18111
18112   jresult = SWIG_csharp_string_callback((const char *)result);
18113   return jresult;
18114 }
18115
18116
18117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18118   unsigned int jresult ;
18119   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18120   std::string *arg2 = 0 ;
18121   Dali::Property::Map *arg3 = 0 ;
18122   bool result;
18123
18124   arg1 = (Dali::BaseObject *)jarg1;
18125   if (!jarg2) {
18126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18127     return 0;
18128   }
18129   std::string arg2_str(jarg2);
18130   arg2 = &arg2_str;
18131   arg3 = (Dali::Property::Map *)jarg3;
18132   if (!arg3) {
18133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18134     return 0;
18135   }
18136   {
18137     try {
18138       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18139     } catch (std::out_of_range& e) {
18140       {
18141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18142       };
18143     } catch (std::exception& e) {
18144       {
18145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18146       };
18147     } catch (Dali::DaliException e) {
18148       {
18149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18150       };
18151     } catch (...) {
18152       {
18153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18154       };
18155     }
18156   }
18157
18158   jresult = result;
18159
18160   //argout typemap for const std::string&
18161
18162   return jresult;
18163 }
18164
18165
18166 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18167   char * jresult ;
18168   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18169   std::string *result = 0 ;
18170
18171   arg1 = (Dali::BaseObject *)jarg1;
18172   {
18173     try {
18174       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18175     } catch (std::out_of_range& e) {
18176       {
18177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18178       };
18179     } catch (std::exception& e) {
18180       {
18181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18182       };
18183     } catch (Dali::DaliException e) {
18184       {
18185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18186       };
18187     } catch (...) {
18188       {
18189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18190       };
18191     }
18192   }
18193
18194   jresult = SWIG_csharp_string_callback(result->c_str());
18195   return jresult;
18196 }
18197
18198
18199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18200   unsigned int jresult ;
18201   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18202   Dali::TypeInfo *arg2 = 0 ;
18203   bool result;
18204
18205   arg1 = (Dali::BaseObject *)jarg1;
18206   arg2 = (Dali::TypeInfo *)jarg2;
18207   if (!arg2) {
18208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18209     return 0;
18210   }
18211   {
18212     try {
18213       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18214     } catch (std::out_of_range& e) {
18215       {
18216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18217       };
18218     } catch (std::exception& e) {
18219       {
18220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18221       };
18222     } catch (Dali::DaliException e) {
18223       {
18224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18225       };
18226     } catch (...) {
18227       {
18228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18229       };
18230     }
18231   }
18232
18233   jresult = result;
18234   return jresult;
18235 }
18236
18237
18238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18239   unsigned int jresult ;
18240   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18241   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18242   std::string *arg3 = 0 ;
18243   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18244   bool result;
18245
18246   arg1 = (Dali::BaseObject *)jarg1;
18247   arg2 = (ConnectionTrackerInterface *)jarg2;
18248   if (!jarg3) {
18249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18250     return 0;
18251   }
18252   std::string arg3_str(jarg3);
18253   arg3 = &arg3_str;
18254   arg4 = (FunctorDelegate *)jarg4;
18255   {
18256     try {
18257       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18258     } catch (std::out_of_range& e) {
18259       {
18260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18261       };
18262     } catch (std::exception& e) {
18263       {
18264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18265       };
18266     } catch (Dali::DaliException e) {
18267       {
18268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18269       };
18270     } catch (...) {
18271       {
18272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18273       };
18274     }
18275   }
18276
18277   jresult = result;
18278
18279   //argout typemap for const std::string&
18280
18281   return jresult;
18282 }
18283
18284
18285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18286   void * jresult ;
18287   Dali::BaseHandle *arg1 = 0 ;
18288   Dali::BaseObject *result = 0 ;
18289
18290   arg1 = (Dali::BaseHandle *)jarg1;
18291   if (!arg1) {
18292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18293     return 0;
18294   }
18295   {
18296     try {
18297       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18298     } catch (std::out_of_range& e) {
18299       {
18300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18301       };
18302     } catch (std::exception& e) {
18303       {
18304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18305       };
18306     } catch (Dali::DaliException e) {
18307       {
18308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18309       };
18310     } catch (...) {
18311       {
18312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18313       };
18314     }
18315   }
18316
18317   jresult = (void *)result;
18318   return jresult;
18319 }
18320
18321
18322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18323   void * jresult ;
18324   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18325   Dali::BaseHandle *result = 0 ;
18326
18327   arg1 = (Dali::BaseObject *)jarg1;
18328   {
18329     try {
18330       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18331     } catch (std::out_of_range& e) {
18332       {
18333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18334       };
18335     } catch (std::exception& e) {
18336       {
18337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18338       };
18339     } catch (Dali::DaliException e) {
18340       {
18341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18342       };
18343     } catch (...) {
18344       {
18345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18346       };
18347     }
18348   }
18349
18350   jresult = (void *)result;
18351   return jresult;
18352 }
18353
18354
18355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18356   void * jresult ;
18357   Dali::BaseHandle *result = 0 ;
18358
18359   {
18360     try {
18361       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18362     } catch (std::out_of_range& e) {
18363       {
18364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18365       };
18366     } catch (std::exception& e) {
18367       {
18368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18369       };
18370     } catch (Dali::DaliException e) {
18371       {
18372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18373       };
18374     } catch (...) {
18375       {
18376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18377       };
18378     }
18379   }
18380
18381   jresult = (void *)result;
18382   return jresult;
18383 }
18384
18385
18386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18387   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18388
18389   arg1 = (Dali::BaseHandle *)jarg1;
18390   {
18391     try {
18392       delete arg1;
18393     } catch (std::out_of_range& e) {
18394       {
18395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18396       };
18397     } catch (std::exception& e) {
18398       {
18399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18400       };
18401     } catch (Dali::DaliException e) {
18402       {
18403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18404       };
18405     } catch (...) {
18406       {
18407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18408       };
18409     }
18410   }
18411
18412 }
18413
18414
18415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18416   void * jresult ;
18417   Dali::BaseHandle *arg1 = 0 ;
18418   Dali::BaseHandle *result = 0 ;
18419
18420   arg1 = (Dali::BaseHandle *)jarg1;
18421   if (!arg1) {
18422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18423     return 0;
18424   }
18425   {
18426     try {
18427       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18428     } catch (std::out_of_range& e) {
18429       {
18430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18431       };
18432     } catch (std::exception& e) {
18433       {
18434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18435       };
18436     } catch (Dali::DaliException e) {
18437       {
18438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18439       };
18440     } catch (...) {
18441       {
18442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18443       };
18444     }
18445   }
18446
18447   jresult = (void *)result;
18448   return jresult;
18449 }
18450
18451
18452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18453   void * jresult ;
18454   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18455   Dali::BaseHandle *arg2 = 0 ;
18456   Dali::BaseHandle *result = 0 ;
18457
18458   arg1 = (Dali::BaseHandle *)jarg1;
18459   arg2 = (Dali::BaseHandle *)jarg2;
18460   if (!arg2) {
18461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18462     return 0;
18463   }
18464   {
18465     try {
18466       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18467     } catch (std::out_of_range& e) {
18468       {
18469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18470       };
18471     } catch (std::exception& e) {
18472       {
18473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18474       };
18475     } catch (Dali::DaliException e) {
18476       {
18477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18478       };
18479     } catch (...) {
18480       {
18481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18482       };
18483     }
18484   }
18485
18486   jresult = (void *)result;
18487   return jresult;
18488 }
18489
18490
18491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18492   unsigned int jresult ;
18493   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18494   std::string *arg2 = 0 ;
18495   Dali::Property::Map *arg3 = 0 ;
18496   bool result;
18497
18498   arg1 = (Dali::BaseHandle *)jarg1;
18499   if (!jarg2) {
18500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18501     return 0;
18502   }
18503   std::string arg2_str(jarg2);
18504   arg2 = &arg2_str;
18505   arg3 = (Dali::Property::Map *)jarg3;
18506   if (!arg3) {
18507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18508     return 0;
18509   }
18510   {
18511     try {
18512       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18513     } catch (std::out_of_range& e) {
18514       {
18515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18516       };
18517     } catch (std::exception& e) {
18518       {
18519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18520       };
18521     } catch (Dali::DaliException e) {
18522       {
18523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18524       };
18525     } catch (...) {
18526       {
18527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18528       };
18529     }
18530   }
18531
18532   jresult = result;
18533
18534   //argout typemap for const std::string&
18535
18536   return jresult;
18537 }
18538
18539
18540 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18541   char * jresult ;
18542   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18543   std::string *result = 0 ;
18544
18545   arg1 = (Dali::BaseHandle *)jarg1;
18546   {
18547     try {
18548       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18549     } catch (std::out_of_range& e) {
18550       {
18551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18552       };
18553     } catch (std::exception& e) {
18554       {
18555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18556       };
18557     } catch (Dali::DaliException e) {
18558       {
18559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18560       };
18561     } catch (...) {
18562       {
18563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18564       };
18565     }
18566   }
18567
18568   jresult = SWIG_csharp_string_callback(result->c_str());
18569   return jresult;
18570 }
18571
18572
18573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18574   unsigned int jresult ;
18575   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18576   Dali::TypeInfo *arg2 = 0 ;
18577   bool result;
18578
18579   arg1 = (Dali::BaseHandle *)jarg1;
18580   arg2 = (Dali::TypeInfo *)jarg2;
18581   if (!arg2) {
18582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18583     return 0;
18584   }
18585   {
18586     try {
18587       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18588     } catch (std::out_of_range& e) {
18589       {
18590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18591       };
18592     } catch (std::exception& e) {
18593       {
18594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18595       };
18596     } catch (Dali::DaliException e) {
18597       {
18598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18599       };
18600     } catch (...) {
18601       {
18602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18603       };
18604     }
18605   }
18606
18607   jresult = result;
18608   return jresult;
18609 }
18610
18611
18612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18613   void * jresult ;
18614   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18615   Dali::BaseObject *result = 0 ;
18616
18617   arg1 = (Dali::BaseHandle *)jarg1;
18618   {
18619     try {
18620       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18621     } catch (std::out_of_range& e) {
18622       {
18623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18624       };
18625     } catch (std::exception& e) {
18626       {
18627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18628       };
18629     } catch (Dali::DaliException e) {
18630       {
18631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18632       };
18633     } catch (...) {
18634       {
18635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18636       };
18637     }
18638   }
18639
18640   jresult = (void *)result;
18641   return jresult;
18642 }
18643
18644
18645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18646   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18647
18648   arg1 = (Dali::BaseHandle *)jarg1;
18649   {
18650     try {
18651       (arg1)->Reset();
18652     } catch (std::out_of_range& e) {
18653       {
18654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18655       };
18656     } catch (std::exception& e) {
18657       {
18658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18659       };
18660     } catch (Dali::DaliException e) {
18661       {
18662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18663       };
18664     } catch (...) {
18665       {
18666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18667       };
18668     }
18669   }
18670
18671 }
18672
18673
18674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18675   unsigned int jresult ;
18676   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18677   Dali::BaseHandle *arg2 = 0 ;
18678   bool result;
18679
18680   arg1 = (Dali::BaseHandle *)jarg1;
18681   arg2 = (Dali::BaseHandle *)jarg2;
18682   if (!arg2) {
18683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18684     return 0;
18685   }
18686   {
18687     try {
18688       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18689     } catch (std::out_of_range& e) {
18690       {
18691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18692       };
18693     } catch (std::exception& e) {
18694       {
18695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18696       };
18697     } catch (Dali::DaliException e) {
18698       {
18699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18700       };
18701     } catch (...) {
18702       {
18703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18704       };
18705     }
18706   }
18707
18708   jresult = result;
18709   return jresult;
18710 }
18711
18712
18713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18714   unsigned int jresult ;
18715   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18716   Dali::BaseHandle *arg2 = 0 ;
18717   bool result;
18718
18719   arg1 = (Dali::BaseHandle *)jarg1;
18720   arg2 = (Dali::BaseHandle *)jarg2;
18721   if (!arg2) {
18722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18723     return 0;
18724   }
18725   {
18726     try {
18727       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18728     } catch (std::out_of_range& e) {
18729       {
18730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18731       };
18732     } catch (std::exception& e) {
18733       {
18734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18735       };
18736     } catch (Dali::DaliException e) {
18737       {
18738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18739       };
18740     } catch (...) {
18741       {
18742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18743       };
18744     }
18745   }
18746
18747   jresult = result;
18748   return jresult;
18749 }
18750
18751
18752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18753   void * jresult ;
18754   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18755   Dali::RefObject *result = 0 ;
18756
18757   arg1 = (Dali::BaseHandle *)jarg1;
18758   {
18759     try {
18760       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18761     } catch (std::out_of_range& e) {
18762       {
18763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18764       };
18765     } catch (std::exception& e) {
18766       {
18767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18768       };
18769     } catch (Dali::DaliException e) {
18770       {
18771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18772       };
18773     } catch (...) {
18774       {
18775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18776       };
18777     }
18778   }
18779
18780   jresult = (void *)result;
18781   return jresult;
18782 }
18783
18784
18785 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18786   unsigned int jresult ;
18787   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18788   bool result;
18789
18790   arg1 = (Dali::BaseHandle *)jarg1;
18791   {
18792     try {
18793       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18794     } catch (std::out_of_range& e) {
18795       {
18796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18797       };
18798     } catch (std::exception& e) {
18799       {
18800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18801       };
18802     } catch (Dali::DaliException e) {
18803       {
18804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18805       };
18806     } catch (...) {
18807       {
18808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18809       };
18810     }
18811   }
18812
18813   jresult = result;
18814   return jresult;
18815 }
18816
18817
18818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18819   unsigned int jresult ;
18820   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18821   Dali::BaseHandle *arg2 = 0 ;
18822   bool result;
18823
18824   arg1 = (Dali::BaseHandle *)jarg1;
18825   arg2 = (Dali::BaseHandle *)jarg2;
18826   if (!arg2) {
18827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18828     return 0;
18829   }
18830   {
18831     try {
18832       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18833     } catch (std::out_of_range& e) {
18834       {
18835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18836       };
18837     } catch (std::exception& e) {
18838       {
18839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18840       };
18841     } catch (Dali::DaliException e) {
18842       {
18843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18844       };
18845     } catch (...) {
18846       {
18847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18848       };
18849     }
18850   }
18851
18852   jresult = result;
18853   return jresult;
18854 }
18855
18856
18857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18858   unsigned int jresult ;
18859   Dali::BaseHandle *arg1 = 0 ;
18860   Dali::BaseHandle *arg2 = 0 ;
18861   bool result;
18862
18863   arg1 = (Dali::BaseHandle *)jarg1;
18864   if (!arg1) {
18865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18866     return 0;
18867   }
18868   arg2 = (Dali::BaseHandle *)jarg2;
18869   if (!arg2) {
18870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18871     return 0;
18872   }
18873   {
18874     try {
18875       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18876     } catch (std::out_of_range& e) {
18877       {
18878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18879       };
18880     } catch (std::exception& e) {
18881       {
18882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18883       };
18884     } catch (Dali::DaliException e) {
18885       {
18886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18887       };
18888     } catch (...) {
18889       {
18890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18891       };
18892     }
18893   }
18894
18895   jresult = result;
18896   return jresult;
18897 }
18898
18899
18900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18901   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18902
18903   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18904   {
18905     try {
18906       delete arg1;
18907     } catch (std::out_of_range& e) {
18908       {
18909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18910       };
18911     } catch (std::exception& e) {
18912       {
18913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18914       };
18915     } catch (Dali::DaliException e) {
18916       {
18917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18918       };
18919     } catch (...) {
18920       {
18921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18922       };
18923     }
18924   }
18925
18926 }
18927
18928
18929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18930   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18931   SlotObserver *arg2 = (SlotObserver *) 0 ;
18932   CallbackBase *arg3 = (CallbackBase *) 0 ;
18933
18934   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18935   arg2 = (SlotObserver *)jarg2;
18936   arg3 = (CallbackBase *)jarg3;
18937   {
18938     try {
18939       (arg1)->SignalConnected(arg2,arg3);
18940     } catch (std::out_of_range& e) {
18941       {
18942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18943       };
18944     } catch (std::exception& e) {
18945       {
18946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18947       };
18948     } catch (Dali::DaliException e) {
18949       {
18950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18951       };
18952     } catch (...) {
18953       {
18954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18955       };
18956     }
18957   }
18958
18959 }
18960
18961
18962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18963   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18964
18965   arg1 = (Dali::SignalObserver *)jarg1;
18966   {
18967     try {
18968       delete arg1;
18969     } catch (std::out_of_range& e) {
18970       {
18971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18972       };
18973     } catch (std::exception& e) {
18974       {
18975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18976       };
18977     } catch (Dali::DaliException e) {
18978       {
18979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18980       };
18981     } catch (...) {
18982       {
18983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18984       };
18985     }
18986   }
18987
18988 }
18989
18990
18991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18992   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18993   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18994   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18995
18996   arg1 = (Dali::SignalObserver *)jarg1;
18997   arg2 = (Dali::SlotObserver *)jarg2;
18998   arg3 = (Dali::CallbackBase *)jarg3;
18999   {
19000     try {
19001       (arg1)->SignalDisconnected(arg2,arg3);
19002     } catch (std::out_of_range& e) {
19003       {
19004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19005       };
19006     } catch (std::exception& e) {
19007       {
19008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19009       };
19010     } catch (Dali::DaliException e) {
19011       {
19012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19013       };
19014     } catch (...) {
19015       {
19016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19017       };
19018     }
19019   }
19020
19021 }
19022
19023
19024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
19025   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19026
19027   arg1 = (Dali::SlotObserver *)jarg1;
19028   {
19029     try {
19030       delete arg1;
19031     } catch (std::out_of_range& e) {
19032       {
19033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19034       };
19035     } catch (std::exception& e) {
19036       {
19037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19038       };
19039     } catch (Dali::DaliException e) {
19040       {
19041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19042       };
19043     } catch (...) {
19044       {
19045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19046       };
19047     }
19048   }
19049
19050 }
19051
19052
19053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19054   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19055   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19056
19057   arg1 = (Dali::SlotObserver *)jarg1;
19058   arg2 = (Dali::CallbackBase *)jarg2;
19059   {
19060     try {
19061       (arg1)->SlotDisconnected(arg2);
19062     } catch (std::out_of_range& e) {
19063       {
19064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19065       };
19066     } catch (std::exception& e) {
19067       {
19068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19069       };
19070     } catch (Dali::DaliException e) {
19071       {
19072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19073       };
19074     } catch (...) {
19075       {
19076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19077       };
19078     }
19079   }
19080
19081 }
19082
19083
19084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19085   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19086
19087   arg1 = (Dali::ConnectionTracker *)jarg1;
19088   {
19089     try {
19090       delete arg1;
19091     } catch (std::out_of_range& e) {
19092       {
19093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19094       };
19095     } catch (std::exception& e) {
19096       {
19097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19098       };
19099     } catch (Dali::DaliException e) {
19100       {
19101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19102       };
19103     } catch (...) {
19104       {
19105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19106       };
19107     }
19108   }
19109
19110 }
19111
19112
19113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19114   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19115
19116   arg1 = (Dali::ConnectionTracker *)jarg1;
19117   {
19118     try {
19119       (arg1)->DisconnectAll();
19120     } catch (std::out_of_range& e) {
19121       {
19122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19123       };
19124     } catch (std::exception& e) {
19125       {
19126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19127       };
19128     } catch (Dali::DaliException e) {
19129       {
19130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19131       };
19132     } catch (...) {
19133       {
19134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19135       };
19136     }
19137   }
19138
19139 }
19140
19141
19142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19143   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19144   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19145   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19146
19147   arg1 = (Dali::ConnectionTracker *)jarg1;
19148   arg2 = (Dali::SlotObserver *)jarg2;
19149   arg3 = (Dali::CallbackBase *)jarg3;
19150   {
19151     try {
19152       (arg1)->SignalConnected(arg2,arg3);
19153     } catch (std::out_of_range& e) {
19154       {
19155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19156       };
19157     } catch (std::exception& e) {
19158       {
19159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19160       };
19161     } catch (Dali::DaliException e) {
19162       {
19163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19164       };
19165     } catch (...) {
19166       {
19167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19168       };
19169     }
19170   }
19171
19172 }
19173
19174
19175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19176   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19177   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19178   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19179
19180   arg1 = (Dali::ConnectionTracker *)jarg1;
19181   arg2 = (Dali::SlotObserver *)jarg2;
19182   arg3 = (Dali::CallbackBase *)jarg3;
19183   {
19184     try {
19185       (arg1)->SignalDisconnected(arg2,arg3);
19186     } catch (std::out_of_range& e) {
19187       {
19188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19189       };
19190     } catch (std::exception& e) {
19191       {
19192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19193       };
19194     } catch (Dali::DaliException e) {
19195       {
19196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19197       };
19198     } catch (...) {
19199       {
19200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19201       };
19202     }
19203   }
19204
19205 }
19206
19207
19208 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19209   unsigned long jresult ;
19210   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19211   std::size_t result;
19212
19213   arg1 = (Dali::ConnectionTracker *)jarg1;
19214   {
19215     try {
19216       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19217     } catch (std::out_of_range& e) {
19218       {
19219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19220       };
19221     } catch (std::exception& e) {
19222       {
19223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19224       };
19225     } catch (Dali::DaliException e) {
19226       {
19227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19228       };
19229     } catch (...) {
19230       {
19231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19232       };
19233     }
19234   }
19235
19236   jresult = (unsigned long)result;
19237   return jresult;
19238 }
19239
19240
19241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19242   void * jresult ;
19243   Dali::ObjectRegistry *result = 0 ;
19244
19245   {
19246     try {
19247       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19248     } catch (std::out_of_range& e) {
19249       {
19250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19251       };
19252     } catch (std::exception& e) {
19253       {
19254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19255       };
19256     } catch (Dali::DaliException e) {
19257       {
19258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19259       };
19260     } catch (...) {
19261       {
19262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19263       };
19264     }
19265   }
19266
19267   jresult = (void *)result;
19268   return jresult;
19269 }
19270
19271
19272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19273   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19274
19275   arg1 = (Dali::ObjectRegistry *)jarg1;
19276   {
19277     try {
19278       delete arg1;
19279     } catch (std::out_of_range& e) {
19280       {
19281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19282       };
19283     } catch (std::exception& e) {
19284       {
19285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19286       };
19287     } catch (Dali::DaliException e) {
19288       {
19289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19290       };
19291     } catch (...) {
19292       {
19293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19294       };
19295     }
19296   }
19297
19298 }
19299
19300
19301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19302   void * jresult ;
19303   Dali::ObjectRegistry *arg1 = 0 ;
19304   Dali::ObjectRegistry *result = 0 ;
19305
19306   arg1 = (Dali::ObjectRegistry *)jarg1;
19307   if (!arg1) {
19308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19309     return 0;
19310   }
19311   {
19312     try {
19313       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19314     } catch (std::out_of_range& e) {
19315       {
19316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19317       };
19318     } catch (std::exception& e) {
19319       {
19320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19321       };
19322     } catch (Dali::DaliException e) {
19323       {
19324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19325       };
19326     } catch (...) {
19327       {
19328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19329       };
19330     }
19331   }
19332
19333   jresult = (void *)result;
19334   return jresult;
19335 }
19336
19337
19338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19339   void * jresult ;
19340   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19341   Dali::ObjectRegistry *arg2 = 0 ;
19342   Dali::ObjectRegistry *result = 0 ;
19343
19344   arg1 = (Dali::ObjectRegistry *)jarg1;
19345   arg2 = (Dali::ObjectRegistry *)jarg2;
19346   if (!arg2) {
19347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19348     return 0;
19349   }
19350   {
19351     try {
19352       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19353     } catch (std::out_of_range& e) {
19354       {
19355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19356       };
19357     } catch (std::exception& e) {
19358       {
19359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19360       };
19361     } catch (Dali::DaliException e) {
19362       {
19363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19364       };
19365     } catch (...) {
19366       {
19367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19368       };
19369     }
19370   }
19371
19372   jresult = (void *)result;
19373   return jresult;
19374 }
19375
19376
19377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19378   void * jresult ;
19379   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19380   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19381
19382   arg1 = (Dali::ObjectRegistry *)jarg1;
19383   {
19384     try {
19385       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19386     } catch (std::out_of_range& e) {
19387       {
19388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19389       };
19390     } catch (std::exception& e) {
19391       {
19392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19393       };
19394     } catch (Dali::DaliException e) {
19395       {
19396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19397       };
19398     } catch (...) {
19399       {
19400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19401       };
19402     }
19403   }
19404
19405   jresult = (void *)result;
19406   return jresult;
19407 }
19408
19409
19410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19411   void * jresult ;
19412   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19413   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19414
19415   arg1 = (Dali::ObjectRegistry *)jarg1;
19416   {
19417     try {
19418       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19419     } catch (std::out_of_range& e) {
19420       {
19421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19422       };
19423     } catch (std::exception& e) {
19424       {
19425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19426       };
19427     } catch (Dali::DaliException e) {
19428       {
19429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19430       };
19431     } catch (...) {
19432       {
19433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19434       };
19435     }
19436   }
19437
19438   jresult = (void *)result;
19439   return jresult;
19440 }
19441
19442
19443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19444   void * jresult ;
19445   Dali::PropertyCondition *result = 0 ;
19446
19447   {
19448     try {
19449       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19450     } catch (std::out_of_range& e) {
19451       {
19452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19453       };
19454     } catch (std::exception& e) {
19455       {
19456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19457       };
19458     } catch (Dali::DaliException e) {
19459       {
19460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19461       };
19462     } catch (...) {
19463       {
19464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19465       };
19466     }
19467   }
19468
19469   jresult = (void *)result;
19470   return jresult;
19471 }
19472
19473
19474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19475   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19476
19477   arg1 = (Dali::PropertyCondition *)jarg1;
19478   {
19479     try {
19480       delete arg1;
19481     } catch (std::out_of_range& e) {
19482       {
19483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19484       };
19485     } catch (std::exception& e) {
19486       {
19487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19488       };
19489     } catch (Dali::DaliException e) {
19490       {
19491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19492       };
19493     } catch (...) {
19494       {
19495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19496       };
19497     }
19498   }
19499
19500 }
19501
19502
19503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19504   void * jresult ;
19505   Dali::PropertyCondition *arg1 = 0 ;
19506   Dali::PropertyCondition *result = 0 ;
19507
19508   arg1 = (Dali::PropertyCondition *)jarg1;
19509   if (!arg1) {
19510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19511     return 0;
19512   }
19513   {
19514     try {
19515       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19516     } catch (std::out_of_range& e) {
19517       {
19518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19519       };
19520     } catch (std::exception& e) {
19521       {
19522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19523       };
19524     } catch (Dali::DaliException e) {
19525       {
19526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19527       };
19528     } catch (...) {
19529       {
19530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19531       };
19532     }
19533   }
19534
19535   jresult = (void *)result;
19536   return jresult;
19537 }
19538
19539
19540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19541   void * jresult ;
19542   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19543   Dali::PropertyCondition *arg2 = 0 ;
19544   Dali::PropertyCondition *result = 0 ;
19545
19546   arg1 = (Dali::PropertyCondition *)jarg1;
19547   arg2 = (Dali::PropertyCondition *)jarg2;
19548   if (!arg2) {
19549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19550     return 0;
19551   }
19552   {
19553     try {
19554       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19555     } catch (std::out_of_range& e) {
19556       {
19557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19558       };
19559     } catch (std::exception& e) {
19560       {
19561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19562       };
19563     } catch (Dali::DaliException e) {
19564       {
19565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19566       };
19567     } catch (...) {
19568       {
19569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19570       };
19571     }
19572   }
19573
19574   jresult = (void *)result;
19575   return jresult;
19576 }
19577
19578
19579 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19580   unsigned long jresult ;
19581   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19582   std::size_t result;
19583
19584   arg1 = (Dali::PropertyCondition *)jarg1;
19585   {
19586     try {
19587       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19588     } catch (std::out_of_range& e) {
19589       {
19590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19591       };
19592     } catch (std::exception& e) {
19593       {
19594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19595       };
19596     } catch (...) {
19597       {
19598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19599       };
19600     }
19601   }
19602   jresult = (unsigned long)result;
19603   return jresult;
19604 }
19605
19606
19607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19608   float jresult ;
19609   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19610   std::size_t arg2 ;
19611   float result;
19612
19613   arg1 = (Dali::PropertyCondition *)jarg1;
19614   arg2 = (std::size_t)jarg2;
19615   {
19616     try {
19617       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19618     } catch (std::out_of_range& e) {
19619       {
19620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19621       };
19622     } catch (std::exception& e) {
19623       {
19624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19625       };
19626     } catch (...) {
19627       {
19628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19629       };
19630     }
19631   }
19632   jresult = result;
19633   return jresult;
19634 }
19635
19636
19637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19638   void * jresult ;
19639   float arg1 ;
19640   Dali::PropertyCondition result;
19641
19642   arg1 = (float)jarg1;
19643   {
19644     try {
19645       result = Dali::LessThanCondition(arg1);
19646     } catch (std::out_of_range& e) {
19647       {
19648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19649       };
19650     } catch (std::exception& e) {
19651       {
19652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19653       };
19654     } catch (Dali::DaliException e) {
19655       {
19656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19657       };
19658     } catch (...) {
19659       {
19660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19661       };
19662     }
19663   }
19664
19665   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19666   return jresult;
19667 }
19668
19669
19670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19671   void * jresult ;
19672   float arg1 ;
19673   Dali::PropertyCondition result;
19674
19675   arg1 = (float)jarg1;
19676   {
19677     try {
19678       result = Dali::GreaterThanCondition(arg1);
19679     } catch (std::out_of_range& e) {
19680       {
19681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19682       };
19683     } catch (std::exception& e) {
19684       {
19685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19686       };
19687     } catch (Dali::DaliException e) {
19688       {
19689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19690       };
19691     } catch (...) {
19692       {
19693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19694       };
19695     }
19696   }
19697
19698   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19699   return jresult;
19700 }
19701
19702
19703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19704   void * jresult ;
19705   float arg1 ;
19706   float arg2 ;
19707   Dali::PropertyCondition result;
19708
19709   arg1 = (float)jarg1;
19710   arg2 = (float)jarg2;
19711   {
19712     try {
19713       result = Dali::InsideCondition(arg1,arg2);
19714     } catch (std::out_of_range& e) {
19715       {
19716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19717       };
19718     } catch (std::exception& e) {
19719       {
19720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19721       };
19722     } catch (Dali::DaliException e) {
19723       {
19724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19725       };
19726     } catch (...) {
19727       {
19728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19729       };
19730     }
19731   }
19732
19733   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19734   return jresult;
19735 }
19736
19737
19738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19739   void * jresult ;
19740   float arg1 ;
19741   float arg2 ;
19742   Dali::PropertyCondition result;
19743
19744   arg1 = (float)jarg1;
19745   arg2 = (float)jarg2;
19746   {
19747     try {
19748       result = Dali::OutsideCondition(arg1,arg2);
19749     } catch (std::out_of_range& e) {
19750       {
19751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19752       };
19753     } catch (std::exception& e) {
19754       {
19755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19756       };
19757     } catch (Dali::DaliException e) {
19758       {
19759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19760       };
19761     } catch (...) {
19762       {
19763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19764       };
19765     }
19766   }
19767
19768   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19769   return jresult;
19770 }
19771
19772
19773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19774   void * jresult ;
19775   float arg1 ;
19776   float arg2 ;
19777   Dali::PropertyCondition result;
19778
19779   arg1 = (float)jarg1;
19780   arg2 = (float)jarg2;
19781   {
19782     try {
19783       result = Dali::StepCondition(arg1,arg2);
19784     } catch (std::out_of_range& e) {
19785       {
19786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19787       };
19788     } catch (std::exception& e) {
19789       {
19790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19791       };
19792     } catch (Dali::DaliException e) {
19793       {
19794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19795       };
19796     } catch (...) {
19797       {
19798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19799       };
19800     }
19801   }
19802
19803   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19804   return jresult;
19805 }
19806
19807
19808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19809   void * jresult ;
19810   float arg1 ;
19811   Dali::PropertyCondition result;
19812
19813   arg1 = (float)jarg1;
19814   {
19815     try {
19816       result = Dali::StepCondition(arg1);
19817     } catch (std::out_of_range& e) {
19818       {
19819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19820       };
19821     } catch (std::exception& e) {
19822       {
19823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19824       };
19825     } catch (Dali::DaliException e) {
19826       {
19827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19828       };
19829     } catch (...) {
19830       {
19831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19832       };
19833     }
19834   }
19835
19836   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19837   return jresult;
19838 }
19839
19840
19841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19842   void * jresult ;
19843   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19844   Dali::PropertyCondition result;
19845
19846   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19847   if (!arg1) {
19848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19849     return 0;
19850   }
19851   {
19852     try {
19853       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19854     } catch (std::out_of_range& e) {
19855       {
19856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19857       };
19858     } catch (std::exception& e) {
19859       {
19860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19861       };
19862     } catch (Dali::DaliException e) {
19863       {
19864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19865       };
19866     } catch (...) {
19867       {
19868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19869       };
19870     }
19871   }
19872
19873   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19874   return jresult;
19875 }
19876
19877
19878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19879   void * jresult ;
19880   Dali::PropertyNotification *result = 0 ;
19881
19882   {
19883     try {
19884       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19885     } catch (std::out_of_range& e) {
19886       {
19887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19888       };
19889     } catch (std::exception& e) {
19890       {
19891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19892       };
19893     } catch (Dali::DaliException e) {
19894       {
19895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19896       };
19897     } catch (...) {
19898       {
19899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19900       };
19901     }
19902   }
19903
19904   jresult = (void *)result;
19905   return jresult;
19906 }
19907
19908
19909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19910   void * jresult ;
19911   Dali::BaseHandle arg1 ;
19912   Dali::BaseHandle *argp1 ;
19913   Dali::PropertyNotification result;
19914
19915   argp1 = (Dali::BaseHandle *)jarg1;
19916   if (!argp1) {
19917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19918     return 0;
19919   }
19920   arg1 = *argp1;
19921   {
19922     try {
19923       result = Dali::PropertyNotification::DownCast(arg1);
19924     } catch (std::out_of_range& e) {
19925       {
19926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19927       };
19928     } catch (std::exception& e) {
19929       {
19930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19931       };
19932     } catch (Dali::DaliException e) {
19933       {
19934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19935       };
19936     } catch (...) {
19937       {
19938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19939       };
19940     }
19941   }
19942
19943   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19944   return jresult;
19945 }
19946
19947
19948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19949   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19950
19951   arg1 = (Dali::PropertyNotification *)jarg1;
19952   {
19953     try {
19954       delete arg1;
19955     } catch (std::out_of_range& e) {
19956       {
19957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19958       };
19959     } catch (std::exception& e) {
19960       {
19961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19962       };
19963     } catch (Dali::DaliException e) {
19964       {
19965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19966       };
19967     } catch (...) {
19968       {
19969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19970       };
19971     }
19972   }
19973
19974 }
19975
19976
19977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19978   void * jresult ;
19979   Dali::PropertyNotification *arg1 = 0 ;
19980   Dali::PropertyNotification *result = 0 ;
19981
19982   arg1 = (Dali::PropertyNotification *)jarg1;
19983   if (!arg1) {
19984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19985     return 0;
19986   }
19987   {
19988     try {
19989       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19990     } catch (std::out_of_range& e) {
19991       {
19992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19993       };
19994     } catch (std::exception& e) {
19995       {
19996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19997       };
19998     } catch (Dali::DaliException e) {
19999       {
20000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20001       };
20002     } catch (...) {
20003       {
20004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20005       };
20006     }
20007   }
20008
20009   jresult = (void *)result;
20010   return jresult;
20011 }
20012
20013
20014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
20015   void * jresult ;
20016   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20017   Dali::PropertyNotification *arg2 = 0 ;
20018   Dali::PropertyNotification *result = 0 ;
20019
20020   arg1 = (Dali::PropertyNotification *)jarg1;
20021   arg2 = (Dali::PropertyNotification *)jarg2;
20022   if (!arg2) {
20023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20024     return 0;
20025   }
20026   {
20027     try {
20028       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
20029     } catch (std::out_of_range& e) {
20030       {
20031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20032       };
20033     } catch (std::exception& e) {
20034       {
20035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20036       };
20037     } catch (Dali::DaliException e) {
20038       {
20039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20040       };
20041     } catch (...) {
20042       {
20043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20044       };
20045     }
20046   }
20047
20048   jresult = (void *)result;
20049   return jresult;
20050 }
20051
20052
20053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20054   void * jresult ;
20055   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20056   Dali::PropertyCondition result;
20057
20058   arg1 = (Dali::PropertyNotification *)jarg1;
20059   {
20060     try {
20061       result = (arg1)->GetCondition();
20062     } catch (std::out_of_range& e) {
20063       {
20064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20065       };
20066     } catch (std::exception& e) {
20067       {
20068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20069       };
20070     } catch (Dali::DaliException e) {
20071       {
20072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20073       };
20074     } catch (...) {
20075       {
20076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20077       };
20078     }
20079   }
20080
20081   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20082   return jresult;
20083 }
20084
20085
20086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20087   void * jresult ;
20088   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20089   Dali::Handle result;
20090
20091   arg1 = (Dali::PropertyNotification *)jarg1;
20092   {
20093     try {
20094       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20095     } catch (std::out_of_range& e) {
20096       {
20097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20098       };
20099     } catch (std::exception& e) {
20100       {
20101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20102       };
20103     } catch (Dali::DaliException e) {
20104       {
20105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20106       };
20107     } catch (...) {
20108       {
20109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20110       };
20111     }
20112   }
20113
20114   jresult = new Dali::Handle((const Dali::Handle &)result);
20115   return jresult;
20116 }
20117
20118
20119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20120   int jresult ;
20121   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20122   Dali::Property::Index result;
20123
20124   arg1 = (Dali::PropertyNotification *)jarg1;
20125   {
20126     try {
20127       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20128     } catch (std::out_of_range& e) {
20129       {
20130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20131       };
20132     } catch (std::exception& e) {
20133       {
20134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20135       };
20136     } catch (Dali::DaliException e) {
20137       {
20138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20139       };
20140     } catch (...) {
20141       {
20142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20143       };
20144     }
20145   }
20146
20147   jresult = result;
20148   return jresult;
20149 }
20150
20151
20152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20153   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20154   Dali::PropertyNotification::NotifyMode arg2 ;
20155
20156   arg1 = (Dali::PropertyNotification *)jarg1;
20157   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20158   {
20159     try {
20160       (arg1)->SetNotifyMode(arg2);
20161     } catch (std::out_of_range& e) {
20162       {
20163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20164       };
20165     } catch (std::exception& e) {
20166       {
20167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20168       };
20169     } catch (Dali::DaliException e) {
20170       {
20171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20172       };
20173     } catch (...) {
20174       {
20175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20176       };
20177     }
20178   }
20179
20180 }
20181
20182
20183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20184   int jresult ;
20185   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20186   Dali::PropertyNotification::NotifyMode result;
20187
20188   arg1 = (Dali::PropertyNotification *)jarg1;
20189   {
20190     try {
20191       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20192     } catch (std::out_of_range& e) {
20193       {
20194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20195       };
20196     } catch (std::exception& e) {
20197       {
20198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20199       };
20200     } catch (Dali::DaliException e) {
20201       {
20202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20203       };
20204     } catch (...) {
20205       {
20206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20207       };
20208     }
20209   }
20210
20211   jresult = (int)result;
20212   return jresult;
20213 }
20214
20215
20216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20217   unsigned int jresult ;
20218   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20219   bool result;
20220
20221   arg1 = (Dali::PropertyNotification *)jarg1;
20222   {
20223     try {
20224       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20225     } catch (std::out_of_range& e) {
20226       {
20227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20228       };
20229     } catch (std::exception& e) {
20230       {
20231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20232       };
20233     } catch (Dali::DaliException e) {
20234       {
20235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20236       };
20237     } catch (...) {
20238       {
20239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20240       };
20241     }
20242   }
20243
20244   jresult = result;
20245   return jresult;
20246 }
20247
20248
20249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20250   void * jresult ;
20251   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20252   Dali::PropertyNotifySignalType *result = 0 ;
20253
20254   arg1 = (Dali::PropertyNotification *)jarg1;
20255   {
20256     try {
20257       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20258     } catch (std::out_of_range& e) {
20259       {
20260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20261       };
20262     } catch (std::exception& e) {
20263       {
20264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20265       };
20266     } catch (Dali::DaliException e) {
20267       {
20268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20269       };
20270     } catch (...) {
20271       {
20272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20273       };
20274     }
20275   }
20276
20277   jresult = (void *)result;
20278   return jresult;
20279 }
20280
20281
20282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20283   void * jresult ;
20284   Dali::Handle *result = 0 ;
20285
20286   {
20287     try {
20288       result = (Dali::Handle *)new Dali::Handle();
20289     } catch (std::out_of_range& e) {
20290       {
20291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20292       };
20293     } catch (std::exception& e) {
20294       {
20295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20296       };
20297     } catch (Dali::DaliException e) {
20298       {
20299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20300       };
20301     } catch (...) {
20302       {
20303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20304       };
20305     }
20306   }
20307
20308   jresult = (void *)result;
20309   return jresult;
20310 }
20311
20312
20313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20314   void * jresult ;
20315   Dali::Handle result;
20316
20317   {
20318     try {
20319       result = Dali::Handle::New();
20320     } catch (std::out_of_range& e) {
20321       {
20322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20323       };
20324     } catch (std::exception& e) {
20325       {
20326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20327       };
20328     } catch (Dali::DaliException e) {
20329       {
20330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20331       };
20332     } catch (...) {
20333       {
20334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20335       };
20336     }
20337   }
20338
20339   jresult = new Dali::Handle((const Dali::Handle &)result);
20340   return jresult;
20341 }
20342
20343
20344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20345   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20346
20347   arg1 = (Dali::Handle *)jarg1;
20348   {
20349     try {
20350       delete arg1;
20351     } catch (std::out_of_range& e) {
20352       {
20353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20354       };
20355     } catch (std::exception& e) {
20356       {
20357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20358       };
20359     } catch (Dali::DaliException e) {
20360       {
20361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20362       };
20363     } catch (...) {
20364       {
20365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20366       };
20367     }
20368   }
20369
20370 }
20371
20372
20373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20374   void * jresult ;
20375   Dali::Handle *arg1 = 0 ;
20376   Dali::Handle *result = 0 ;
20377
20378   arg1 = (Dali::Handle *)jarg1;
20379   if (!arg1) {
20380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20381     return 0;
20382   }
20383   {
20384     try {
20385       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20386     } catch (std::out_of_range& e) {
20387       {
20388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20389       };
20390     } catch (std::exception& e) {
20391       {
20392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20393       };
20394     } catch (Dali::DaliException e) {
20395       {
20396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20397       };
20398     } catch (...) {
20399       {
20400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20401       };
20402     }
20403   }
20404
20405   jresult = (void *)result;
20406   return jresult;
20407 }
20408
20409
20410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20411   void * jresult ;
20412   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20413   Dali::Handle *arg2 = 0 ;
20414   Dali::Handle *result = 0 ;
20415
20416   arg1 = (Dali::Handle *)jarg1;
20417   arg2 = (Dali::Handle *)jarg2;
20418   if (!arg2) {
20419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20420     return 0;
20421   }
20422   {
20423     try {
20424       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20425     } catch (std::out_of_range& e) {
20426       {
20427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20428       };
20429     } catch (std::exception& e) {
20430       {
20431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20432       };
20433     } catch (Dali::DaliException e) {
20434       {
20435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20436       };
20437     } catch (...) {
20438       {
20439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20440       };
20441     }
20442   }
20443
20444   jresult = (void *)result;
20445   return jresult;
20446 }
20447
20448
20449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20450   void * jresult ;
20451   Dali::BaseHandle arg1 ;
20452   Dali::BaseHandle *argp1 ;
20453   Dali::Handle result;
20454
20455   argp1 = (Dali::BaseHandle *)jarg1;
20456   if (!argp1) {
20457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20458     return 0;
20459   }
20460   arg1 = *argp1;
20461   {
20462     try {
20463       result = Dali::Handle::DownCast(arg1);
20464     } catch (std::out_of_range& e) {
20465       {
20466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20467       };
20468     } catch (std::exception& e) {
20469       {
20470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20471       };
20472     } catch (Dali::DaliException e) {
20473       {
20474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20475       };
20476     } catch (...) {
20477       {
20478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20479       };
20480     }
20481   }
20482
20483   jresult = new Dali::Handle((const Dali::Handle &)result);
20484   return jresult;
20485 }
20486
20487
20488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20489   unsigned int jresult ;
20490   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20491   Dali::Handle::Capability arg2 ;
20492   bool result;
20493
20494   arg1 = (Dali::Handle *)jarg1;
20495   arg2 = (Dali::Handle::Capability)jarg2;
20496   {
20497     try {
20498       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20499     } catch (std::out_of_range& e) {
20500       {
20501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20502       };
20503     } catch (std::exception& e) {
20504       {
20505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20506       };
20507     } catch (Dali::DaliException e) {
20508       {
20509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20510       };
20511     } catch (...) {
20512       {
20513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20514       };
20515     }
20516   }
20517
20518   jresult = result;
20519   return jresult;
20520 }
20521
20522
20523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20524   unsigned int jresult ;
20525   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20526   unsigned int result;
20527
20528   arg1 = (Dali::Handle *)jarg1;
20529   {
20530     try {
20531       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20532     } catch (std::out_of_range& e) {
20533       {
20534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20535       };
20536     } catch (std::exception& e) {
20537       {
20538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20539       };
20540     } catch (Dali::DaliException e) {
20541       {
20542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20543       };
20544     } catch (...) {
20545       {
20546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20547       };
20548     }
20549   }
20550
20551   jresult = result;
20552   return jresult;
20553 }
20554
20555
20556 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20557   char * jresult ;
20558   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20559   Dali::Property::Index arg2 ;
20560   std::string result;
20561
20562   arg1 = (Dali::Handle *)jarg1;
20563   arg2 = (Dali::Property::Index)jarg2;
20564   {
20565     try {
20566       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20567     } catch (std::out_of_range& e) {
20568       {
20569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20570       };
20571     } catch (std::exception& e) {
20572       {
20573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20574       };
20575     } catch (Dali::DaliException e) {
20576       {
20577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20578       };
20579     } catch (...) {
20580       {
20581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20582       };
20583     }
20584   }
20585
20586   jresult = SWIG_csharp_string_callback((&result)->c_str());
20587   return jresult;
20588 }
20589
20590
20591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20592   int jresult ;
20593   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20594   std::string *arg2 = 0 ;
20595   Dali::Property::Index result;
20596
20597   arg1 = (Dali::Handle *)jarg1;
20598   if (!jarg2) {
20599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20600     return 0;
20601   }
20602   std::string arg2_str(jarg2);
20603   arg2 = &arg2_str;
20604   {
20605     try {
20606       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20607     } catch (std::out_of_range& e) {
20608       {
20609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20610       };
20611     } catch (std::exception& e) {
20612       {
20613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20614       };
20615     } catch (Dali::DaliException e) {
20616       {
20617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20618       };
20619     } catch (...) {
20620       {
20621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20622       };
20623     }
20624   }
20625
20626   jresult = result;
20627
20628   //argout typemap for const std::string&
20629
20630   return jresult;
20631 }
20632
20633
20634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20635   unsigned int jresult ;
20636   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20637   Dali::Property::Index arg2 ;
20638   bool result;
20639
20640   arg1 = (Dali::Handle *)jarg1;
20641   arg2 = (Dali::Property::Index)jarg2;
20642   {
20643     try {
20644       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20645     } catch (std::out_of_range& e) {
20646       {
20647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20648       };
20649     } catch (std::exception& e) {
20650       {
20651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20652       };
20653     } catch (Dali::DaliException e) {
20654       {
20655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20656       };
20657     } catch (...) {
20658       {
20659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20660       };
20661     }
20662   }
20663
20664   jresult = result;
20665   return jresult;
20666 }
20667
20668
20669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20670   unsigned int jresult ;
20671   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20672   Dali::Property::Index arg2 ;
20673   bool result;
20674
20675   arg1 = (Dali::Handle *)jarg1;
20676   arg2 = (Dali::Property::Index)jarg2;
20677   {
20678     try {
20679       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20680     } catch (std::out_of_range& e) {
20681       {
20682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20683       };
20684     } catch (std::exception& e) {
20685       {
20686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20687       };
20688     } catch (Dali::DaliException e) {
20689       {
20690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20691       };
20692     } catch (...) {
20693       {
20694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20695       };
20696     }
20697   }
20698
20699   jresult = result;
20700   return jresult;
20701 }
20702
20703
20704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20705   unsigned int jresult ;
20706   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20707   Dali::Property::Index arg2 ;
20708   bool result;
20709
20710   arg1 = (Dali::Handle *)jarg1;
20711   arg2 = (Dali::Property::Index)jarg2;
20712   {
20713     try {
20714       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20715     } catch (std::out_of_range& e) {
20716       {
20717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20718       };
20719     } catch (std::exception& e) {
20720       {
20721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20722       };
20723     } catch (Dali::DaliException e) {
20724       {
20725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20726       };
20727     } catch (...) {
20728       {
20729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20730       };
20731     }
20732   }
20733
20734   jresult = result;
20735   return jresult;
20736 }
20737
20738
20739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20740   int jresult ;
20741   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20742   Dali::Property::Index arg2 ;
20743   Dali::Property::Type result;
20744
20745   arg1 = (Dali::Handle *)jarg1;
20746   arg2 = (Dali::Property::Index)jarg2;
20747   {
20748     try {
20749       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20750     } catch (std::out_of_range& e) {
20751       {
20752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20753       };
20754     } catch (std::exception& e) {
20755       {
20756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20757       };
20758     } catch (Dali::DaliException e) {
20759       {
20760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20761       };
20762     } catch (...) {
20763       {
20764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20765       };
20766     }
20767   }
20768
20769   jresult = (int)result;
20770   return jresult;
20771 }
20772
20773
20774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20775   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20776   Dali::Property::Index arg2 ;
20777   Dali::Property::Value *arg3 = 0 ;
20778
20779   arg1 = (Dali::Handle *)jarg1;
20780   arg2 = (Dali::Property::Index)jarg2;
20781   arg3 = (Dali::Property::Value *)jarg3;
20782   if (!arg3) {
20783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20784     return ;
20785   }
20786   {
20787     try {
20788       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20789     } catch (std::out_of_range& e) {
20790       {
20791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20792       };
20793     } catch (std::exception& e) {
20794       {
20795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20796       };
20797     } catch (Dali::DaliException e) {
20798       {
20799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20800       };
20801     } catch (...) {
20802       {
20803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20804       };
20805     }
20806   }
20807
20808 }
20809
20810
20811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20812   int jresult ;
20813   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20814   std::string *arg2 = 0 ;
20815   Dali::Property::Value *arg3 = 0 ;
20816   Dali::Property::Index result;
20817
20818   arg1 = (Dali::Handle *)jarg1;
20819   if (!jarg2) {
20820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20821     return 0;
20822   }
20823   std::string arg2_str(jarg2);
20824   arg2 = &arg2_str;
20825   arg3 = (Dali::Property::Value *)jarg3;
20826   if (!arg3) {
20827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20828     return 0;
20829   }
20830   {
20831     try {
20832       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20833     } catch (std::out_of_range& e) {
20834       {
20835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20836       };
20837     } catch (std::exception& e) {
20838       {
20839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20840       };
20841     } catch (Dali::DaliException e) {
20842       {
20843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20844       };
20845     } catch (...) {
20846       {
20847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20848       };
20849     }
20850   }
20851
20852   jresult = result;
20853
20854   //argout typemap for const std::string&
20855
20856   return jresult;
20857 }
20858
20859
20860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20861   int jresult ;
20862   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20863   std::string *arg2 = 0 ;
20864   Dali::Property::Value *arg3 = 0 ;
20865   Dali::Property::AccessMode arg4 ;
20866   Dali::Property::Index result;
20867
20868   arg1 = (Dali::Handle *)jarg1;
20869   if (!jarg2) {
20870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20871     return 0;
20872   }
20873   std::string arg2_str(jarg2);
20874   arg2 = &arg2_str;
20875   arg3 = (Dali::Property::Value *)jarg3;
20876   if (!arg3) {
20877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20878     return 0;
20879   }
20880   arg4 = (Dali::Property::AccessMode)jarg4;
20881   {
20882     try {
20883       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20884     } catch (std::out_of_range& e) {
20885       {
20886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20887       };
20888     } catch (std::exception& e) {
20889       {
20890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20891       };
20892     } catch (Dali::DaliException e) {
20893       {
20894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20895       };
20896     } catch (...) {
20897       {
20898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20899       };
20900     }
20901   }
20902
20903   jresult = result;
20904
20905   //argout typemap for const std::string&
20906
20907   return jresult;
20908 }
20909
20910
20911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20912   void * jresult ;
20913   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20914   Dali::Property::Index arg2 ;
20915   Dali::Property::Value result;
20916
20917   arg1 = (Dali::Handle *)jarg1;
20918   arg2 = (Dali::Property::Index)jarg2;
20919   {
20920     try {
20921       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20922     } catch (std::out_of_range& e) {
20923       {
20924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20925       };
20926     } catch (std::exception& e) {
20927       {
20928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20929       };
20930     } catch (Dali::DaliException e) {
20931       {
20932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20933       };
20934     } catch (...) {
20935       {
20936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20937       };
20938     }
20939   }
20940
20941   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20942   return jresult;
20943 }
20944
20945
20946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20947   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20948   Dali::Property::IndexContainer *arg2 = 0 ;
20949
20950   arg1 = (Dali::Handle *)jarg1;
20951   arg2 = (Dali::Property::IndexContainer *)jarg2;
20952   if (!arg2) {
20953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20954     return ;
20955   }
20956   {
20957     try {
20958       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20959     } catch (std::out_of_range& e) {
20960       {
20961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20962       };
20963     } catch (std::exception& e) {
20964       {
20965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20966       };
20967     } catch (Dali::DaliException e) {
20968       {
20969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20970       };
20971     } catch (...) {
20972       {
20973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20974       };
20975     }
20976   }
20977
20978 }
20979
20980
20981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20982   void * jresult ;
20983   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20984   Dali::Property::Index arg2 ;
20985   Dali::PropertyCondition *arg3 = 0 ;
20986   Dali::PropertyNotification result;
20987
20988   arg1 = (Dali::Handle *)jarg1;
20989   arg2 = (Dali::Property::Index)jarg2;
20990   arg3 = (Dali::PropertyCondition *)jarg3;
20991   if (!arg3) {
20992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20993     return 0;
20994   }
20995   {
20996     try {
20997       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20998     } catch (std::out_of_range& e) {
20999       {
21000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21001       };
21002     } catch (std::exception& e) {
21003       {
21004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21005       };
21006     } catch (Dali::DaliException e) {
21007       {
21008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21009       };
21010     } catch (...) {
21011       {
21012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21013       };
21014     }
21015   }
21016
21017   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21018   return jresult;
21019 }
21020
21021
21022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
21023   void * jresult ;
21024   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21025   Dali::Property::Index arg2 ;
21026   int arg3 ;
21027   Dali::PropertyCondition *arg4 = 0 ;
21028   Dali::PropertyNotification result;
21029
21030   arg1 = (Dali::Handle *)jarg1;
21031   arg2 = (Dali::Property::Index)jarg2;
21032   arg3 = (int)jarg3;
21033   arg4 = (Dali::PropertyCondition *)jarg4;
21034   if (!arg4) {
21035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21036     return 0;
21037   }
21038   {
21039     try {
21040       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21041     } catch (std::out_of_range& e) {
21042       {
21043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21044       };
21045     } catch (std::exception& e) {
21046       {
21047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21048       };
21049     } catch (Dali::DaliException e) {
21050       {
21051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21052       };
21053     } catch (...) {
21054       {
21055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21056       };
21057     }
21058   }
21059
21060   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21061   return jresult;
21062 }
21063
21064
21065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21066   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21067   Dali::PropertyNotification arg2 ;
21068   Dali::PropertyNotification *argp2 ;
21069
21070   arg1 = (Dali::Handle *)jarg1;
21071   argp2 = (Dali::PropertyNotification *)jarg2;
21072   if (!argp2) {
21073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21074     return ;
21075   }
21076   arg2 = *argp2;
21077   {
21078     try {
21079       (arg1)->RemovePropertyNotification(arg2);
21080     } catch (std::out_of_range& e) {
21081       {
21082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21083       };
21084     } catch (std::exception& e) {
21085       {
21086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21087       };
21088     } catch (Dali::DaliException e) {
21089       {
21090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21091       };
21092     } catch (...) {
21093       {
21094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21095       };
21096     }
21097   }
21098
21099 }
21100
21101
21102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21103   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21104
21105   arg1 = (Dali::Handle *)jarg1;
21106   {
21107     try {
21108       (arg1)->RemovePropertyNotifications();
21109     } catch (std::out_of_range& e) {
21110       {
21111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21112       };
21113     } catch (std::exception& e) {
21114       {
21115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21116       };
21117     } catch (Dali::DaliException e) {
21118       {
21119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21120       };
21121     } catch (...) {
21122       {
21123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21124       };
21125     }
21126   }
21127
21128 }
21129
21130
21131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21132   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21133
21134   arg1 = (Dali::Handle *)jarg1;
21135   {
21136     try {
21137       (arg1)->RemoveConstraints();
21138     } catch (std::out_of_range& e) {
21139       {
21140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21141       };
21142     } catch (std::exception& e) {
21143       {
21144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21145       };
21146     } catch (Dali::DaliException e) {
21147       {
21148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21149       };
21150     } catch (...) {
21151       {
21152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21153       };
21154     }
21155   }
21156
21157 }
21158
21159
21160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21161   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21162   unsigned int arg2 ;
21163
21164   arg1 = (Dali::Handle *)jarg1;
21165   arg2 = (unsigned int)jarg2;
21166   {
21167     try {
21168       (arg1)->RemoveConstraints(arg2);
21169     } catch (std::out_of_range& e) {
21170       {
21171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21172       };
21173     } catch (std::exception& e) {
21174       {
21175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21176       };
21177     } catch (Dali::DaliException e) {
21178       {
21179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21180       };
21181     } catch (...) {
21182       {
21183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21184       };
21185     }
21186   }
21187
21188 }
21189
21190
21191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21192   int jresult ;
21193   Dali::Property::Index result;
21194
21195   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21196   jresult = result;
21197   return jresult;
21198 }
21199
21200
21201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21202   void * jresult ;
21203   Dali::Handle result;
21204
21205   {
21206     try {
21207       result = Dali::WeightObject::New();
21208     } catch (std::out_of_range& e) {
21209       {
21210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21211       };
21212     } catch (std::exception& e) {
21213       {
21214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21215       };
21216     } catch (Dali::DaliException e) {
21217       {
21218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21219       };
21220     } catch (...) {
21221       {
21222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21223       };
21224     }
21225   }
21226
21227   jresult = new Dali::Handle((const Dali::Handle &)result);
21228   return jresult;
21229 }
21230
21231
21232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21233   void * jresult ;
21234   Dali::TypeInfo *result = 0 ;
21235
21236   {
21237     try {
21238       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21239     } catch (std::out_of_range& e) {
21240       {
21241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21242       };
21243     } catch (std::exception& e) {
21244       {
21245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21246       };
21247     } catch (Dali::DaliException e) {
21248       {
21249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21250       };
21251     } catch (...) {
21252       {
21253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21254       };
21255     }
21256   }
21257
21258   jresult = (void *)result;
21259   return jresult;
21260 }
21261
21262
21263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21264   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21265
21266   arg1 = (Dali::TypeInfo *)jarg1;
21267   {
21268     try {
21269       delete arg1;
21270     } catch (std::out_of_range& e) {
21271       {
21272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21273       };
21274     } catch (std::exception& e) {
21275       {
21276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21277       };
21278     } catch (Dali::DaliException e) {
21279       {
21280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21281       };
21282     } catch (...) {
21283       {
21284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21285       };
21286     }
21287   }
21288
21289 }
21290
21291
21292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21293   void * jresult ;
21294   Dali::TypeInfo *arg1 = 0 ;
21295   Dali::TypeInfo *result = 0 ;
21296
21297   arg1 = (Dali::TypeInfo *)jarg1;
21298   if (!arg1) {
21299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21300     return 0;
21301   }
21302   {
21303     try {
21304       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21305     } catch (std::out_of_range& e) {
21306       {
21307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21308       };
21309     } catch (std::exception& e) {
21310       {
21311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21312       };
21313     } catch (Dali::DaliException e) {
21314       {
21315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21316       };
21317     } catch (...) {
21318       {
21319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21320       };
21321     }
21322   }
21323
21324   jresult = (void *)result;
21325   return jresult;
21326 }
21327
21328
21329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21330   void * jresult ;
21331   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21332   Dali::TypeInfo *arg2 = 0 ;
21333   Dali::TypeInfo *result = 0 ;
21334
21335   arg1 = (Dali::TypeInfo *)jarg1;
21336   arg2 = (Dali::TypeInfo *)jarg2;
21337   if (!arg2) {
21338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21339     return 0;
21340   }
21341   {
21342     try {
21343       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21344     } catch (std::out_of_range& e) {
21345       {
21346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21347       };
21348     } catch (std::exception& e) {
21349       {
21350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21351       };
21352     } catch (Dali::DaliException e) {
21353       {
21354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21355       };
21356     } catch (...) {
21357       {
21358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21359       };
21360     }
21361   }
21362
21363   jresult = (void *)result;
21364   return jresult;
21365 }
21366
21367
21368 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21369   char * jresult ;
21370   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21371   std::string *result = 0 ;
21372
21373   arg1 = (Dali::TypeInfo *)jarg1;
21374   {
21375     try {
21376       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21377     } catch (std::out_of_range& e) {
21378       {
21379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21380       };
21381     } catch (std::exception& e) {
21382       {
21383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21384       };
21385     } catch (Dali::DaliException e) {
21386       {
21387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21388       };
21389     } catch (...) {
21390       {
21391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21392       };
21393     }
21394   }
21395
21396   jresult = SWIG_csharp_string_callback(result->c_str());
21397   return jresult;
21398 }
21399
21400
21401 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21402   char * jresult ;
21403   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21404   std::string *result = 0 ;
21405
21406   arg1 = (Dali::TypeInfo *)jarg1;
21407   {
21408     try {
21409       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21410     } catch (std::out_of_range& e) {
21411       {
21412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21413       };
21414     } catch (std::exception& e) {
21415       {
21416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21417       };
21418     } catch (Dali::DaliException e) {
21419       {
21420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21421       };
21422     } catch (...) {
21423       {
21424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21425       };
21426     }
21427   }
21428
21429   jresult = SWIG_csharp_string_callback(result->c_str());
21430   return jresult;
21431 }
21432
21433
21434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21435   void * jresult ;
21436   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21437   Dali::BaseHandle result;
21438
21439   arg1 = (Dali::TypeInfo *)jarg1;
21440   {
21441     try {
21442       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21443     } catch (std::out_of_range& e) {
21444       {
21445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21446       };
21447     } catch (std::exception& e) {
21448       {
21449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21450       };
21451     } catch (Dali::DaliException e) {
21452       {
21453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21454       };
21455     } catch (...) {
21456       {
21457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21458       };
21459     }
21460   }
21461
21462   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21463   return jresult;
21464 }
21465
21466
21467 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21468   unsigned long jresult ;
21469   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21470   size_t result;
21471
21472   arg1 = (Dali::TypeInfo *)jarg1;
21473   {
21474     try {
21475       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21476     } catch (std::out_of_range& e) {
21477       {
21478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21479       };
21480     } catch (std::exception& e) {
21481       {
21482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21483       };
21484     } catch (Dali::DaliException e) {
21485       {
21486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21487       };
21488     } catch (...) {
21489       {
21490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21491       };
21492     }
21493   }
21494
21495   jresult = (unsigned long)result;
21496   return jresult;
21497 }
21498
21499
21500 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21501   char * jresult ;
21502   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21503   size_t arg2 ;
21504   std::string result;
21505
21506   arg1 = (Dali::TypeInfo *)jarg1;
21507   arg2 = (size_t)jarg2;
21508   {
21509     try {
21510       result = (arg1)->GetActionName(arg2);
21511     } catch (std::out_of_range& e) {
21512       {
21513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21514       };
21515     } catch (std::exception& e) {
21516       {
21517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21518       };
21519     } catch (Dali::DaliException e) {
21520       {
21521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21522       };
21523     } catch (...) {
21524       {
21525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21526       };
21527     }
21528   }
21529
21530   jresult = SWIG_csharp_string_callback((&result)->c_str());
21531   return jresult;
21532 }
21533
21534
21535 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21536   unsigned long jresult ;
21537   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21538   size_t result;
21539
21540   arg1 = (Dali::TypeInfo *)jarg1;
21541   {
21542     try {
21543       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21544     } catch (std::out_of_range& e) {
21545       {
21546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21547       };
21548     } catch (std::exception& e) {
21549       {
21550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21551       };
21552     } catch (Dali::DaliException e) {
21553       {
21554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21555       };
21556     } catch (...) {
21557       {
21558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21559       };
21560     }
21561   }
21562
21563   jresult = (unsigned long)result;
21564   return jresult;
21565 }
21566
21567
21568 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21569   char * jresult ;
21570   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21571   size_t arg2 ;
21572   std::string result;
21573
21574   arg1 = (Dali::TypeInfo *)jarg1;
21575   arg2 = (size_t)jarg2;
21576   {
21577     try {
21578       result = (arg1)->GetSignalName(arg2);
21579     } catch (std::out_of_range& e) {
21580       {
21581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21582       };
21583     } catch (std::exception& e) {
21584       {
21585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21586       };
21587     } catch (Dali::DaliException e) {
21588       {
21589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21590       };
21591     } catch (...) {
21592       {
21593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21594       };
21595     }
21596   }
21597
21598   jresult = SWIG_csharp_string_callback((&result)->c_str());
21599   return jresult;
21600 }
21601
21602
21603 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21604   unsigned long jresult ;
21605   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21606   size_t result;
21607
21608   arg1 = (Dali::TypeInfo *)jarg1;
21609   {
21610     try {
21611       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21612     } catch (std::out_of_range& e) {
21613       {
21614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21615       };
21616     } catch (std::exception& e) {
21617       {
21618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21619       };
21620     } catch (Dali::DaliException e) {
21621       {
21622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21623       };
21624     } catch (...) {
21625       {
21626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21627       };
21628     }
21629   }
21630
21631   jresult = (unsigned long)result;
21632   return jresult;
21633 }
21634
21635
21636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21637   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21638   Dali::Property::IndexContainer *arg2 = 0 ;
21639
21640   arg1 = (Dali::TypeInfo *)jarg1;
21641   arg2 = (Dali::Property::IndexContainer *)jarg2;
21642   if (!arg2) {
21643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21644     return ;
21645   }
21646   {
21647     try {
21648       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21649     } catch (std::out_of_range& e) {
21650       {
21651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21652       };
21653     } catch (std::exception& e) {
21654       {
21655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21656       };
21657     } catch (Dali::DaliException e) {
21658       {
21659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21660       };
21661     } catch (...) {
21662       {
21663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21664       };
21665     }
21666   }
21667
21668 }
21669
21670
21671 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21672   char * jresult ;
21673   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21674   Dali::Property::Index arg2 ;
21675   std::string *result = 0 ;
21676
21677   arg1 = (Dali::TypeInfo *)jarg1;
21678   arg2 = (Dali::Property::Index)jarg2;
21679   {
21680     try {
21681       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21682     } catch (std::out_of_range& e) {
21683       {
21684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21685       };
21686     } catch (std::exception& e) {
21687       {
21688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21689       };
21690     } catch (Dali::DaliException e) {
21691       {
21692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21693       };
21694     } catch (...) {
21695       {
21696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21697       };
21698     }
21699   }
21700
21701   jresult = SWIG_csharp_string_callback(result->c_str());
21702   return jresult;
21703 }
21704
21705
21706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21707   void * jresult ;
21708   Dali::TypeRegistry result;
21709
21710   {
21711     try {
21712       result = Dali::TypeRegistry::Get();
21713     } catch (std::out_of_range& e) {
21714       {
21715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21716       };
21717     } catch (std::exception& e) {
21718       {
21719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21720       };
21721     } catch (Dali::DaliException e) {
21722       {
21723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21724       };
21725     } catch (...) {
21726       {
21727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21728       };
21729     }
21730   }
21731
21732   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21733   return jresult;
21734 }
21735
21736
21737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21738   void * jresult ;
21739   Dali::TypeRegistry *result = 0 ;
21740
21741   {
21742     try {
21743       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21744     } catch (std::out_of_range& e) {
21745       {
21746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21747       };
21748     } catch (std::exception& e) {
21749       {
21750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21751       };
21752     } catch (Dali::DaliException e) {
21753       {
21754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21755       };
21756     } catch (...) {
21757       {
21758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21759       };
21760     }
21761   }
21762
21763   jresult = (void *)result;
21764   return jresult;
21765 }
21766
21767
21768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21769   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21770
21771   arg1 = (Dali::TypeRegistry *)jarg1;
21772   {
21773     try {
21774       delete arg1;
21775     } catch (std::out_of_range& e) {
21776       {
21777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21778       };
21779     } catch (std::exception& e) {
21780       {
21781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21782       };
21783     } catch (Dali::DaliException e) {
21784       {
21785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21786       };
21787     } catch (...) {
21788       {
21789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21790       };
21791     }
21792   }
21793
21794 }
21795
21796
21797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21798   void * jresult ;
21799   Dali::TypeRegistry *arg1 = 0 ;
21800   Dali::TypeRegistry *result = 0 ;
21801
21802   arg1 = (Dali::TypeRegistry *)jarg1;
21803   if (!arg1) {
21804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21805     return 0;
21806   }
21807   {
21808     try {
21809       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21810     } catch (std::out_of_range& e) {
21811       {
21812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21813       };
21814     } catch (std::exception& e) {
21815       {
21816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21817       };
21818     } catch (Dali::DaliException e) {
21819       {
21820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21821       };
21822     } catch (...) {
21823       {
21824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21825       };
21826     }
21827   }
21828
21829   jresult = (void *)result;
21830   return jresult;
21831 }
21832
21833
21834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21835   void * jresult ;
21836   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21837   Dali::TypeRegistry *arg2 = 0 ;
21838   Dali::TypeRegistry *result = 0 ;
21839
21840   arg1 = (Dali::TypeRegistry *)jarg1;
21841   arg2 = (Dali::TypeRegistry *)jarg2;
21842   if (!arg2) {
21843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21844     return 0;
21845   }
21846   {
21847     try {
21848       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21849     } catch (std::out_of_range& e) {
21850       {
21851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21852       };
21853     } catch (std::exception& e) {
21854       {
21855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21856       };
21857     } catch (Dali::DaliException e) {
21858       {
21859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21860       };
21861     } catch (...) {
21862       {
21863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21864       };
21865     }
21866   }
21867
21868   jresult = (void *)result;
21869   return jresult;
21870 }
21871
21872
21873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21874   void * jresult ;
21875   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21876   std::string *arg2 = 0 ;
21877   Dali::TypeInfo result;
21878
21879   arg1 = (Dali::TypeRegistry *)jarg1;
21880   if (!jarg2) {
21881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21882     return 0;
21883   }
21884   std::string arg2_str(jarg2);
21885   arg2 = &arg2_str;
21886   {
21887     try {
21888       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21889     } catch (std::out_of_range& e) {
21890       {
21891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21892       };
21893     } catch (std::exception& e) {
21894       {
21895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21896       };
21897     } catch (Dali::DaliException e) {
21898       {
21899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21900       };
21901     } catch (...) {
21902       {
21903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21904       };
21905     }
21906   }
21907
21908   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21909
21910   //argout typemap for const std::string&
21911
21912   return jresult;
21913 }
21914
21915
21916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21917   void * jresult ;
21918   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21919   std::type_info *arg2 = 0 ;
21920   Dali::TypeInfo result;
21921
21922   arg1 = (Dali::TypeRegistry *)jarg1;
21923   arg2 = (std::type_info *)jarg2;
21924   if (!arg2) {
21925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21926     return 0;
21927   }
21928   {
21929     try {
21930       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21931     } catch (std::out_of_range& e) {
21932       {
21933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21934       };
21935     } catch (std::exception& e) {
21936       {
21937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21938       };
21939     } catch (Dali::DaliException e) {
21940       {
21941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21942       };
21943     } catch (...) {
21944       {
21945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21946       };
21947     }
21948   }
21949
21950   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21951   return jresult;
21952 }
21953
21954
21955 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21956   unsigned long jresult ;
21957   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21958   size_t result;
21959
21960   arg1 = (Dali::TypeRegistry *)jarg1;
21961   {
21962     try {
21963       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21964     } catch (std::out_of_range& e) {
21965       {
21966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21967       };
21968     } catch (std::exception& e) {
21969       {
21970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21971       };
21972     } catch (Dali::DaliException e) {
21973       {
21974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21975       };
21976     } catch (...) {
21977       {
21978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21979       };
21980     }
21981   }
21982
21983   jresult = (unsigned long)result;
21984   return jresult;
21985 }
21986
21987
21988 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21989   char * jresult ;
21990   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21991   size_t arg2 ;
21992   std::string result;
21993
21994   arg1 = (Dali::TypeRegistry *)jarg1;
21995   arg2 = (size_t)jarg2;
21996   {
21997     try {
21998       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21999     } catch (std::out_of_range& e) {
22000       {
22001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22002       };
22003     } catch (std::exception& e) {
22004       {
22005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22006       };
22007     } catch (Dali::DaliException e) {
22008       {
22009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22010       };
22011     } catch (...) {
22012       {
22013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22014       };
22015     }
22016   }
22017
22018   jresult = SWIG_csharp_string_callback((&result)->c_str());
22019   return jresult;
22020 }
22021
22022
22023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22024   void * jresult ;
22025   std::type_info *arg1 = 0 ;
22026   std::type_info *arg2 = 0 ;
22027   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22028   Dali::TypeRegistration *result = 0 ;
22029
22030   arg1 = (std::type_info *)jarg1;
22031   if (!arg1) {
22032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22033     return 0;
22034   }
22035   arg2 = (std::type_info *)jarg2;
22036   if (!arg2) {
22037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22038     return 0;
22039   }
22040   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22041   {
22042     try {
22043       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22044     } catch (std::out_of_range& e) {
22045       {
22046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22047       };
22048     } catch (std::exception& e) {
22049       {
22050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22051       };
22052     } catch (Dali::DaliException e) {
22053       {
22054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22055       };
22056     } catch (...) {
22057       {
22058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22059       };
22060     }
22061   }
22062
22063   jresult = (void *)result;
22064   return jresult;
22065 }
22066
22067
22068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22069   void * jresult ;
22070   std::type_info *arg1 = 0 ;
22071   std::type_info *arg2 = 0 ;
22072   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22073   bool arg4 ;
22074   Dali::TypeRegistration *result = 0 ;
22075
22076   arg1 = (std::type_info *)jarg1;
22077   if (!arg1) {
22078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22079     return 0;
22080   }
22081   arg2 = (std::type_info *)jarg2;
22082   if (!arg2) {
22083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22084     return 0;
22085   }
22086   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22087   arg4 = jarg4 ? true : false;
22088   {
22089     try {
22090       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22091     } catch (std::out_of_range& e) {
22092       {
22093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22094       };
22095     } catch (std::exception& e) {
22096       {
22097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22098       };
22099     } catch (Dali::DaliException e) {
22100       {
22101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22102       };
22103     } catch (...) {
22104       {
22105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22106       };
22107     }
22108   }
22109
22110   jresult = (void *)result;
22111   return jresult;
22112 }
22113
22114
22115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22116   void * jresult ;
22117   std::string *arg1 = 0 ;
22118   std::type_info *arg2 = 0 ;
22119   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22120   Dali::TypeRegistration *result = 0 ;
22121
22122   if (!jarg1) {
22123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22124     return 0;
22125   }
22126   std::string arg1_str(jarg1);
22127   arg1 = &arg1_str;
22128   arg2 = (std::type_info *)jarg2;
22129   if (!arg2) {
22130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22131     return 0;
22132   }
22133   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22134   {
22135     try {
22136       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22137     } catch (std::out_of_range& e) {
22138       {
22139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22140       };
22141     } catch (std::exception& e) {
22142       {
22143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22144       };
22145     } catch (Dali::DaliException e) {
22146       {
22147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22148       };
22149     } catch (...) {
22150       {
22151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22152       };
22153     }
22154   }
22155
22156   jresult = (void *)result;
22157
22158   //argout typemap for const std::string&
22159
22160   return jresult;
22161 }
22162
22163
22164 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22165   char * jresult ;
22166   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22167   std::string result;
22168
22169   arg1 = (Dali::TypeRegistration *)jarg1;
22170   {
22171     try {
22172       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22173     } catch (std::out_of_range& e) {
22174       {
22175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22176       };
22177     } catch (std::exception& e) {
22178       {
22179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22180       };
22181     } catch (Dali::DaliException e) {
22182       {
22183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22184       };
22185     } catch (...) {
22186       {
22187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22188       };
22189     }
22190   }
22191
22192   jresult = SWIG_csharp_string_callback((&result)->c_str());
22193   return jresult;
22194 }
22195
22196
22197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22198   std::string *arg1 = 0 ;
22199   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22200
22201   if (!jarg1) {
22202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22203     return ;
22204   }
22205   std::string arg1_str(jarg1);
22206   arg1 = &arg1_str;
22207   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22208   {
22209     try {
22210       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22211     } catch (std::out_of_range& e) {
22212       {
22213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22214       };
22215     } catch (std::exception& e) {
22216       {
22217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22218       };
22219     } catch (Dali::DaliException e) {
22220       {
22221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22222       };
22223     } catch (...) {
22224       {
22225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22226       };
22227     }
22228   }
22229
22230
22231   //argout typemap for const std::string&
22232
22233 }
22234
22235
22236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22237   std::string *arg1 = 0 ;
22238   std::string *arg2 = 0 ;
22239   int arg3 ;
22240   Dali::Property::Type arg4 ;
22241   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22242   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22243
22244   if (!jarg1) {
22245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22246     return ;
22247   }
22248   std::string arg1_str(jarg1);
22249   arg1 = &arg1_str;
22250   if (!jarg2) {
22251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22252     return ;
22253   }
22254   std::string arg2_str(jarg2);
22255   arg2 = &arg2_str;
22256   arg3 = (int)jarg3;
22257   arg4 = (Dali::Property::Type)jarg4;
22258   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22259   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22260   {
22261     try {
22262       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22263     } catch (std::out_of_range& e) {
22264       {
22265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22266       };
22267     } catch (std::exception& e) {
22268       {
22269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22270       };
22271     } catch (Dali::DaliException e) {
22272       {
22273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22274       };
22275     } catch (...) {
22276       {
22277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22278       };
22279     }
22280   }
22281
22282
22283   //argout typemap for const std::string&
22284
22285
22286   //argout typemap for const std::string&
22287
22288 }
22289
22290
22291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22292   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22293
22294   arg1 = (Dali::TypeRegistration *)jarg1;
22295   {
22296     try {
22297       delete arg1;
22298     } catch (std::out_of_range& e) {
22299       {
22300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22301       };
22302     } catch (std::exception& e) {
22303       {
22304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22305       };
22306     } catch (Dali::DaliException e) {
22307       {
22308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22309       };
22310     } catch (...) {
22311       {
22312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22313       };
22314     }
22315   }
22316
22317 }
22318
22319
22320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22321   void * jresult ;
22322   Dali::TypeRegistration *arg1 = 0 ;
22323   std::string *arg2 = 0 ;
22324   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22325   Dali::SignalConnectorType *result = 0 ;
22326
22327   arg1 = (Dali::TypeRegistration *)jarg1;
22328   if (!arg1) {
22329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22330     return 0;
22331   }
22332   if (!jarg2) {
22333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22334     return 0;
22335   }
22336   std::string arg2_str(jarg2);
22337   arg2 = &arg2_str;
22338   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22339   {
22340     try {
22341       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22342     } catch (std::out_of_range& e) {
22343       {
22344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22345       };
22346     } catch (std::exception& e) {
22347       {
22348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22349       };
22350     } catch (Dali::DaliException e) {
22351       {
22352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22353       };
22354     } catch (...) {
22355       {
22356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22357       };
22358     }
22359   }
22360
22361   jresult = (void *)result;
22362
22363   //argout typemap for const std::string&
22364
22365   return jresult;
22366 }
22367
22368
22369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22370   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22371
22372   arg1 = (Dali::SignalConnectorType *)jarg1;
22373   {
22374     try {
22375       delete arg1;
22376     } catch (std::out_of_range& e) {
22377       {
22378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22379       };
22380     } catch (std::exception& e) {
22381       {
22382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22383       };
22384     } catch (Dali::DaliException e) {
22385       {
22386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22387       };
22388     } catch (...) {
22389       {
22390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22391       };
22392     }
22393   }
22394
22395 }
22396
22397
22398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22399   void * jresult ;
22400   Dali::TypeRegistration *arg1 = 0 ;
22401   std::string *arg2 = 0 ;
22402   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22403   Dali::TypeAction *result = 0 ;
22404
22405   arg1 = (Dali::TypeRegistration *)jarg1;
22406   if (!arg1) {
22407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22408     return 0;
22409   }
22410   if (!jarg2) {
22411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22412     return 0;
22413   }
22414   std::string arg2_str(jarg2);
22415   arg2 = &arg2_str;
22416   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22417   {
22418     try {
22419       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22420     } catch (std::out_of_range& e) {
22421       {
22422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22423       };
22424     } catch (std::exception& e) {
22425       {
22426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22427       };
22428     } catch (Dali::DaliException e) {
22429       {
22430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22431       };
22432     } catch (...) {
22433       {
22434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22435       };
22436     }
22437   }
22438
22439   jresult = (void *)result;
22440
22441   //argout typemap for const std::string&
22442
22443   return jresult;
22444 }
22445
22446
22447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22448   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22449
22450   arg1 = (Dali::TypeAction *)jarg1;
22451   {
22452     try {
22453       delete arg1;
22454     } catch (std::out_of_range& e) {
22455       {
22456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22457       };
22458     } catch (std::exception& e) {
22459       {
22460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22461       };
22462     } catch (Dali::DaliException e) {
22463       {
22464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22465       };
22466     } catch (...) {
22467       {
22468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22469       };
22470     }
22471   }
22472
22473 }
22474
22475
22476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22477   void * jresult ;
22478   Dali::TypeRegistration *arg1 = 0 ;
22479   std::string *arg2 = 0 ;
22480   Dali::Property::Index arg3 ;
22481   Dali::Property::Type arg4 ;
22482   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22483   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22484   Dali::PropertyRegistration *result = 0 ;
22485
22486   arg1 = (Dali::TypeRegistration *)jarg1;
22487   if (!arg1) {
22488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22489     return 0;
22490   }
22491   if (!jarg2) {
22492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22493     return 0;
22494   }
22495   std::string arg2_str(jarg2);
22496   arg2 = &arg2_str;
22497   arg3 = (Dali::Property::Index)jarg3;
22498   arg4 = (Dali::Property::Type)jarg4;
22499   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22500   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22501   {
22502     try {
22503       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22504     } catch (std::out_of_range& e) {
22505       {
22506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22507       };
22508     } catch (std::exception& e) {
22509       {
22510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22511       };
22512     } catch (Dali::DaliException e) {
22513       {
22514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22515       };
22516     } catch (...) {
22517       {
22518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22519       };
22520     }
22521   }
22522
22523   jresult = (void *)result;
22524
22525   //argout typemap for const std::string&
22526
22527   return jresult;
22528 }
22529
22530
22531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22532   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22533
22534   arg1 = (Dali::PropertyRegistration *)jarg1;
22535   {
22536     try {
22537       delete arg1;
22538     } catch (std::out_of_range& e) {
22539       {
22540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22541       };
22542     } catch (std::exception& e) {
22543       {
22544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22545       };
22546     } catch (Dali::DaliException e) {
22547       {
22548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22549       };
22550     } catch (...) {
22551       {
22552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22553       };
22554     }
22555   }
22556
22557 }
22558
22559
22560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22561   void * jresult ;
22562   Dali::TypeRegistration *arg1 = 0 ;
22563   std::string *arg2 = 0 ;
22564   Dali::Property::Index arg3 ;
22565   Dali::Property::Type arg4 ;
22566   Dali::AnimatablePropertyRegistration *result = 0 ;
22567
22568   arg1 = (Dali::TypeRegistration *)jarg1;
22569   if (!arg1) {
22570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22571     return 0;
22572   }
22573   if (!jarg2) {
22574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22575     return 0;
22576   }
22577   std::string arg2_str(jarg2);
22578   arg2 = &arg2_str;
22579   arg3 = (Dali::Property::Index)jarg3;
22580   arg4 = (Dali::Property::Type)jarg4;
22581   {
22582     try {
22583       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,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_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22612   void * jresult ;
22613   Dali::TypeRegistration *arg1 = 0 ;
22614   std::string *arg2 = 0 ;
22615   Dali::Property::Index arg3 ;
22616   Dali::Property::Value *arg4 = 0 ;
22617   Dali::AnimatablePropertyRegistration *result = 0 ;
22618
22619   arg1 = (Dali::TypeRegistration *)jarg1;
22620   if (!arg1) {
22621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22622     return 0;
22623   }
22624   if (!jarg2) {
22625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22626     return 0;
22627   }
22628   std::string arg2_str(jarg2);
22629   arg2 = &arg2_str;
22630   arg3 = (Dali::Property::Index)jarg3;
22631   arg4 = (Dali::Property::Value *)jarg4;
22632   if (!arg4) {
22633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22634     return 0;
22635   }
22636   {
22637     try {
22638       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22639     } catch (std::out_of_range& e) {
22640       {
22641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22642       };
22643     } catch (std::exception& e) {
22644       {
22645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22646       };
22647     } catch (Dali::DaliException e) {
22648       {
22649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22650       };
22651     } catch (...) {
22652       {
22653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22654       };
22655     }
22656   }
22657
22658   jresult = (void *)result;
22659
22660   //argout typemap for const std::string&
22661
22662   return jresult;
22663 }
22664
22665
22666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22667   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22668
22669   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22670   {
22671     try {
22672       delete arg1;
22673     } catch (std::out_of_range& e) {
22674       {
22675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22676       };
22677     } catch (std::exception& e) {
22678       {
22679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22680       };
22681     } catch (Dali::DaliException e) {
22682       {
22683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22684       };
22685     } catch (...) {
22686       {
22687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22688       };
22689     }
22690   }
22691
22692 }
22693
22694
22695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22696   void * jresult ;
22697   Dali::TypeRegistration *arg1 = 0 ;
22698   std::string *arg2 = 0 ;
22699   Dali::Property::Index arg3 ;
22700   Dali::Property::Index arg4 ;
22701   unsigned int arg5 ;
22702   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22703
22704   arg1 = (Dali::TypeRegistration *)jarg1;
22705   if (!arg1) {
22706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22707     return 0;
22708   }
22709   if (!jarg2) {
22710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22711     return 0;
22712   }
22713   std::string arg2_str(jarg2);
22714   arg2 = &arg2_str;
22715   arg3 = (Dali::Property::Index)jarg3;
22716   arg4 = (Dali::Property::Index)jarg4;
22717   arg5 = (unsigned int)jarg5;
22718   {
22719     try {
22720       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22721     } catch (std::out_of_range& e) {
22722       {
22723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22724       };
22725     } catch (std::exception& e) {
22726       {
22727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22728       };
22729     } catch (Dali::DaliException e) {
22730       {
22731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22732       };
22733     } catch (...) {
22734       {
22735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22736       };
22737     }
22738   }
22739
22740   jresult = (void *)result;
22741
22742   //argout typemap for const std::string&
22743
22744   return jresult;
22745 }
22746
22747
22748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22749   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22750
22751   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22752   {
22753     try {
22754       delete arg1;
22755     } catch (std::out_of_range& e) {
22756       {
22757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22758       };
22759     } catch (std::exception& e) {
22760       {
22761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22762       };
22763     } catch (Dali::DaliException e) {
22764       {
22765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22766       };
22767     } catch (...) {
22768       {
22769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22770       };
22771     }
22772   }
22773
22774 }
22775
22776
22777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22778   void * jresult ;
22779   Dali::TypeRegistration *arg1 = 0 ;
22780   std::string *arg2 = 0 ;
22781   Dali::Property::Index arg3 ;
22782   Dali::Property::Type arg4 ;
22783   Dali::ChildPropertyRegistration *result = 0 ;
22784
22785   arg1 = (Dali::TypeRegistration *)jarg1;
22786   if (!arg1) {
22787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22788     return 0;
22789   }
22790   if (!jarg2) {
22791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22792     return 0;
22793   }
22794   std::string arg2_str(jarg2);
22795   arg2 = &arg2_str;
22796   arg3 = (Dali::Property::Index)jarg3;
22797   arg4 = (Dali::Property::Type)jarg4;
22798   {
22799     try {
22800       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22801     } catch (std::out_of_range& e) {
22802       {
22803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22804       };
22805     } catch (std::exception& e) {
22806       {
22807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22808       };
22809     } catch (Dali::DaliException e) {
22810       {
22811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22812       };
22813     } catch (...) {
22814       {
22815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22816       };
22817     }
22818   }
22819
22820   jresult = (void *)result;
22821
22822   //argout typemap for const std::string&
22823
22824   return jresult;
22825 }
22826
22827
22828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22829   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22830
22831   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22832   {
22833     try {
22834       delete arg1;
22835     } catch (std::out_of_range& e) {
22836       {
22837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22838       };
22839     } catch (std::exception& e) {
22840       {
22841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22842       };
22843     } catch (Dali::DaliException e) {
22844       {
22845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22846       };
22847     } catch (...) {
22848       {
22849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22850       };
22851     }
22852   }
22853
22854 }
22855
22856
22857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22858   unsigned int jresult ;
22859   std::string *arg1 = 0 ;
22860   std::type_info *arg2 = 0 ;
22861   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22862   bool result;
22863
22864   if (!jarg1) {
22865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22866     return 0;
22867   }
22868   std::string arg1_str(jarg1);
22869   arg1 = &arg1_str;
22870   arg2 = (std::type_info *)jarg2;
22871   if (!arg2) {
22872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22873     return 0;
22874   }
22875   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22876   {
22877     try {
22878       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22879     } catch (std::out_of_range& e) {
22880       {
22881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22882       };
22883     } catch (std::exception& e) {
22884       {
22885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22886       };
22887     } catch (Dali::DaliException e) {
22888       {
22889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22890       };
22891     } catch (...) {
22892       {
22893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22894       };
22895     }
22896   }
22897
22898   jresult = result;
22899
22900   //argout typemap for const std::string&
22901
22902   return jresult;
22903 }
22904
22905
22906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22907   unsigned int jresult ;
22908   std::string *arg1 = 0 ;
22909   std::string *arg2 = 0 ;
22910   Dali::Property::Index arg3 ;
22911   Dali::Property::Type arg4 ;
22912   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22913   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22914   bool result;
22915
22916   if (!jarg1) {
22917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22918     return 0;
22919   }
22920   std::string arg1_str(jarg1);
22921   arg1 = &arg1_str;
22922   if (!jarg2) {
22923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22924     return 0;
22925   }
22926   std::string arg2_str(jarg2);
22927   arg2 = &arg2_str;
22928   arg3 = (Dali::Property::Index)jarg3;
22929   arg4 = (Dali::Property::Type)jarg4;
22930   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22931   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22932   {
22933     try {
22934       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22935     } catch (std::out_of_range& e) {
22936       {
22937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22938       };
22939     } catch (std::exception& e) {
22940       {
22941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22942       };
22943     } catch (Dali::DaliException e) {
22944       {
22945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22946       };
22947     } catch (...) {
22948       {
22949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22950       };
22951     }
22952   }
22953
22954   jresult = result;
22955
22956   //argout typemap for const std::string&
22957
22958
22959   //argout typemap for const std::string&
22960
22961   return jresult;
22962 }
22963
22964
22965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22966   float jresult ;
22967   float result;
22968
22969   result = (float)(float)Dali::ParentOrigin::TOP;
22970   jresult = result;
22971   return jresult;
22972 }
22973
22974
22975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22976   float jresult ;
22977   float result;
22978
22979   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22980   jresult = result;
22981   return jresult;
22982 }
22983
22984
22985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22986   float jresult ;
22987   float result;
22988
22989   result = (float)(float)Dali::ParentOrigin::LEFT;
22990   jresult = result;
22991   return jresult;
22992 }
22993
22994
22995 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22996   float jresult ;
22997   float result;
22998
22999   result = (float)(float)Dali::ParentOrigin::RIGHT;
23000   jresult = result;
23001   return jresult;
23002 }
23003
23004
23005 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
23006   float jresult ;
23007   float result;
23008
23009   result = (float)(float)Dali::ParentOrigin::MIDDLE;
23010   jresult = result;
23011   return jresult;
23012 }
23013
23014
23015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
23016   void * jresult ;
23017   Dali::Vector3 *result = 0 ;
23018
23019   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
23020   jresult = (void *)result;
23021   return jresult;
23022 }
23023
23024
23025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
23026   void * jresult ;
23027   Dali::Vector3 *result = 0 ;
23028
23029   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
23030   jresult = (void *)result;
23031   return jresult;
23032 }
23033
23034
23035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23036   void * jresult ;
23037   Dali::Vector3 *result = 0 ;
23038
23039   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23040   jresult = (void *)result;
23041   return jresult;
23042 }
23043
23044
23045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23046   void * jresult ;
23047   Dali::Vector3 *result = 0 ;
23048
23049   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23050   jresult = (void *)result;
23051   return jresult;
23052 }
23053
23054
23055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23056   void * jresult ;
23057   Dali::Vector3 *result = 0 ;
23058
23059   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23060   jresult = (void *)result;
23061   return jresult;
23062 }
23063
23064
23065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23066   void * jresult ;
23067   Dali::Vector3 *result = 0 ;
23068
23069   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23070   jresult = (void *)result;
23071   return jresult;
23072 }
23073
23074
23075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23076   void * jresult ;
23077   Dali::Vector3 *result = 0 ;
23078
23079   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23080   jresult = (void *)result;
23081   return jresult;
23082 }
23083
23084
23085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23086   void * jresult ;
23087   Dali::Vector3 *result = 0 ;
23088
23089   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23090   jresult = (void *)result;
23091   return jresult;
23092 }
23093
23094
23095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23096   void * jresult ;
23097   Dali::Vector3 *result = 0 ;
23098
23099   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23100   jresult = (void *)result;
23101   return jresult;
23102 }
23103
23104
23105 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23106   float jresult ;
23107   float result;
23108
23109   result = (float)(float)Dali::AnchorPoint::TOP;
23110   jresult = result;
23111   return jresult;
23112 }
23113
23114
23115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23116   float jresult ;
23117   float result;
23118
23119   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23120   jresult = result;
23121   return jresult;
23122 }
23123
23124
23125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23126   float jresult ;
23127   float result;
23128
23129   result = (float)(float)Dali::AnchorPoint::LEFT;
23130   jresult = result;
23131   return jresult;
23132 }
23133
23134
23135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23136   float jresult ;
23137   float result;
23138
23139   result = (float)(float)Dali::AnchorPoint::RIGHT;
23140   jresult = result;
23141   return jresult;
23142 }
23143
23144
23145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23146   float jresult ;
23147   float result;
23148
23149   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23150   jresult = result;
23151   return jresult;
23152 }
23153
23154
23155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23156   void * jresult ;
23157   Dali::Vector3 *result = 0 ;
23158
23159   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23160   jresult = (void *)result;
23161   return jresult;
23162 }
23163
23164
23165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23166   void * jresult ;
23167   Dali::Vector3 *result = 0 ;
23168
23169   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23170   jresult = (void *)result;
23171   return jresult;
23172 }
23173
23174
23175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23176   void * jresult ;
23177   Dali::Vector3 *result = 0 ;
23178
23179   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23180   jresult = (void *)result;
23181   return jresult;
23182 }
23183
23184
23185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23186   void * jresult ;
23187   Dali::Vector3 *result = 0 ;
23188
23189   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23190   jresult = (void *)result;
23191   return jresult;
23192 }
23193
23194
23195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23196   void * jresult ;
23197   Dali::Vector3 *result = 0 ;
23198
23199   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23200   jresult = (void *)result;
23201   return jresult;
23202 }
23203
23204
23205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23206   void * jresult ;
23207   Dali::Vector3 *result = 0 ;
23208
23209   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23210   jresult = (void *)result;
23211   return jresult;
23212 }
23213
23214
23215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23216   void * jresult ;
23217   Dali::Vector3 *result = 0 ;
23218
23219   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23220   jresult = (void *)result;
23221   return jresult;
23222 }
23223
23224
23225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23226   void * jresult ;
23227   Dali::Vector3 *result = 0 ;
23228
23229   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23230   jresult = (void *)result;
23231   return jresult;
23232 }
23233
23234
23235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23236   void * jresult ;
23237   Dali::Vector3 *result = 0 ;
23238
23239   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23240   jresult = (void *)result;
23241   return jresult;
23242 }
23243
23244
23245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23246   void * jresult ;
23247   Dali::Vector4 *result = 0 ;
23248
23249   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23250   jresult = (void *)result;
23251   return jresult;
23252 }
23253
23254
23255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23256   void * jresult ;
23257   Dali::Vector4 *result = 0 ;
23258
23259   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23260   jresult = (void *)result;
23261   return jresult;
23262 }
23263
23264
23265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23266   void * jresult ;
23267   Dali::Vector4 *result = 0 ;
23268
23269   result = (Dali::Vector4 *)&Dali::Color::RED;
23270   jresult = (void *)result;
23271   return jresult;
23272 }
23273
23274
23275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23276   void * jresult ;
23277   Dali::Vector4 *result = 0 ;
23278
23279   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23280   jresult = (void *)result;
23281   return jresult;
23282 }
23283
23284
23285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23286   void * jresult ;
23287   Dali::Vector4 *result = 0 ;
23288
23289   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23290   jresult = (void *)result;
23291   return jresult;
23292 }
23293
23294
23295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23296   void * jresult ;
23297   Dali::Vector4 *result = 0 ;
23298
23299   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23300   jresult = (void *)result;
23301   return jresult;
23302 }
23303
23304
23305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23306   void * jresult ;
23307   Dali::Vector4 *result = 0 ;
23308
23309   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23310   jresult = (void *)result;
23311   return jresult;
23312 }
23313
23314
23315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23316   void * jresult ;
23317   Dali::Vector4 *result = 0 ;
23318
23319   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23320   jresult = (void *)result;
23321   return jresult;
23322 }
23323
23324
23325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23326   void * jresult ;
23327   Dali::Vector4 *result = 0 ;
23328
23329   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23330   jresult = (void *)result;
23331   return jresult;
23332 }
23333
23334
23335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23336   float jresult ;
23337   float result;
23338
23339   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23340   jresult = result;
23341   return jresult;
23342 }
23343
23344
23345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23346   float jresult ;
23347   float result;
23348
23349   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23350   jresult = result;
23351   return jresult;
23352 }
23353
23354
23355 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23356   float jresult ;
23357   float result;
23358
23359   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23360   jresult = result;
23361   return jresult;
23362 }
23363
23364
23365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23366   float jresult ;
23367   float result;
23368
23369   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23370   jresult = result;
23371   return jresult;
23372 }
23373
23374
23375 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23376   float jresult ;
23377   float result;
23378
23379   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23380   jresult = result;
23381   return jresult;
23382 }
23383
23384
23385 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23386   float jresult ;
23387   float result;
23388
23389   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23390   jresult = result;
23391   return jresult;
23392 }
23393
23394
23395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23396   float jresult ;
23397   float result;
23398
23399   result = (float)(float)Dali::Math::PI;
23400   jresult = result;
23401   return jresult;
23402 }
23403
23404
23405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23406   float jresult ;
23407   float result;
23408
23409   result = (float)(float)Dali::Math::PI_2;
23410   jresult = result;
23411   return jresult;
23412 }
23413
23414
23415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23416   float jresult ;
23417   float result;
23418
23419   result = (float)(float)Dali::Math::PI_4;
23420   jresult = result;
23421   return jresult;
23422 }
23423
23424
23425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23426   float jresult ;
23427   float result;
23428
23429   result = (float)(float)Dali::Math::PI_OVER_180;
23430   jresult = result;
23431   return jresult;
23432 }
23433
23434
23435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23436   float jresult ;
23437   float result;
23438
23439   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23440   jresult = result;
23441   return jresult;
23442 }
23443
23444
23445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23446   int jresult ;
23447   Dali::ResizePolicy::Type result;
23448
23449   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23450   jresult = (int)result;
23451   return jresult;
23452 }
23453
23454
23455 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23456   unsigned long jresult ;
23457   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23458   Dali::VectorBase::SizeType result;
23459
23460   arg1 = (Dali::VectorBase *)jarg1;
23461   {
23462     try {
23463       result = ((Dali::VectorBase const *)arg1)->Count();
23464     } catch (std::out_of_range& e) {
23465       {
23466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23467       };
23468     } catch (std::exception& e) {
23469       {
23470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23471       };
23472     } catch (Dali::DaliException e) {
23473       {
23474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23475       };
23476     } catch (...) {
23477       {
23478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23479       };
23480     }
23481   }
23482
23483   jresult = (unsigned long)result;
23484   return jresult;
23485 }
23486
23487
23488 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23489   unsigned long jresult ;
23490   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23491   Dali::VectorBase::SizeType result;
23492
23493   arg1 = (Dali::VectorBase *)jarg1;
23494   {
23495     try {
23496       result = ((Dali::VectorBase const *)arg1)->Size();
23497     } catch (std::out_of_range& e) {
23498       {
23499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23500       };
23501     } catch (std::exception& e) {
23502       {
23503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23504       };
23505     } catch (Dali::DaliException e) {
23506       {
23507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23508       };
23509     } catch (...) {
23510       {
23511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23512       };
23513     }
23514   }
23515
23516   jresult = (unsigned long)result;
23517   return jresult;
23518 }
23519
23520
23521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23522   unsigned int jresult ;
23523   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23524   bool result;
23525
23526   arg1 = (Dali::VectorBase *)jarg1;
23527   {
23528     try {
23529       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23530     } catch (std::out_of_range& e) {
23531       {
23532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23533       };
23534     } catch (std::exception& e) {
23535       {
23536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23537       };
23538     } catch (Dali::DaliException e) {
23539       {
23540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23541       };
23542     } catch (...) {
23543       {
23544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23545       };
23546     }
23547   }
23548
23549   jresult = result;
23550   return jresult;
23551 }
23552
23553
23554 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23555   unsigned long jresult ;
23556   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23557   Dali::VectorBase::SizeType result;
23558
23559   arg1 = (Dali::VectorBase *)jarg1;
23560   {
23561     try {
23562       result = ((Dali::VectorBase const *)arg1)->Capacity();
23563     } catch (std::out_of_range& e) {
23564       {
23565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23566       };
23567     } catch (std::exception& e) {
23568       {
23569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23570       };
23571     } catch (Dali::DaliException e) {
23572       {
23573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23574       };
23575     } catch (...) {
23576       {
23577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23578       };
23579     }
23580   }
23581
23582   jresult = (unsigned long)result;
23583   return jresult;
23584 }
23585
23586
23587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23588   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23589
23590   arg1 = (Dali::VectorBase *)jarg1;
23591   {
23592     try {
23593       (arg1)->Release();
23594     } catch (std::out_of_range& e) {
23595       {
23596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23597       };
23598     } catch (std::exception& e) {
23599       {
23600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23601       };
23602     } catch (Dali::DaliException e) {
23603       {
23604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23605       };
23606     } catch (...) {
23607       {
23608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23609       };
23610     }
23611   }
23612
23613 }
23614
23615
23616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23617   int jresult ;
23618   Dali::Pixel::Format result;
23619
23620   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23621   jresult = (int)result;
23622   return jresult;
23623 }
23624
23625
23626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23627   int jresult ;
23628   Dali::Pixel::Format result;
23629
23630   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23631   jresult = (int)result;
23632   return jresult;
23633 }
23634
23635
23636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23637   unsigned int jresult ;
23638   Dali::Pixel::Format arg1 ;
23639   bool result;
23640
23641   arg1 = (Dali::Pixel::Format)jarg1;
23642   {
23643     try {
23644       result = (bool)Dali::Pixel::HasAlpha(arg1);
23645     } catch (std::out_of_range& e) {
23646       {
23647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23648       };
23649     } catch (std::exception& e) {
23650       {
23651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23652       };
23653     } catch (Dali::DaliException e) {
23654       {
23655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23656       };
23657     } catch (...) {
23658       {
23659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23660       };
23661     }
23662   }
23663
23664   jresult = result;
23665   return jresult;
23666 }
23667
23668
23669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23670   unsigned int jresult ;
23671   Dali::Pixel::Format arg1 ;
23672   unsigned int result;
23673
23674   arg1 = (Dali::Pixel::Format)jarg1;
23675   {
23676     try {
23677       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23678     } catch (std::out_of_range& e) {
23679       {
23680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23681       };
23682     } catch (std::exception& e) {
23683       {
23684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23685       };
23686     } catch (Dali::DaliException e) {
23687       {
23688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23689       };
23690     } catch (...) {
23691       {
23692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23693       };
23694     }
23695   }
23696
23697   jresult = result;
23698   return jresult;
23699 }
23700
23701
23702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23703   Dali::Pixel::Format arg1 ;
23704   int *arg2 = 0 ;
23705   int *arg3 = 0 ;
23706
23707   arg1 = (Dali::Pixel::Format)jarg1;
23708   arg2 = (int *)jarg2;
23709   if (!arg2) {
23710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23711     return ;
23712   }
23713   arg3 = (int *)jarg3;
23714   if (!arg3) {
23715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23716     return ;
23717   }
23718   {
23719     try {
23720       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23721     } catch (std::out_of_range& e) {
23722       {
23723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23724       };
23725     } catch (std::exception& e) {
23726       {
23727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23728       };
23729     } catch (Dali::DaliException e) {
23730       {
23731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23732       };
23733     } catch (...) {
23734       {
23735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23736       };
23737     }
23738   }
23739
23740 }
23741
23742
23743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23744   void * jresult ;
23745   unsigned char *arg1 = (unsigned char *) 0 ;
23746   unsigned int arg2 ;
23747   unsigned int arg3 ;
23748   unsigned int arg4 ;
23749   Dali::Pixel::Format arg5 ;
23750   Dali::PixelData::ReleaseFunction arg6 ;
23751   Dali::PixelData result;
23752
23753   arg1 = jarg1;
23754   arg2 = (unsigned int)jarg2;
23755   arg3 = (unsigned int)jarg3;
23756   arg4 = (unsigned int)jarg4;
23757   arg5 = (Dali::Pixel::Format)jarg5;
23758   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23759   {
23760     try {
23761       auto pixelBuffer = new unsigned char[jarg2];
23762       memcpy( pixelBuffer, arg1, arg2);
23763       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23764     } catch (std::out_of_range& e) {
23765       {
23766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23767       };
23768     } catch (std::exception& e) {
23769       {
23770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23771       };
23772     } catch (Dali::DaliException e) {
23773       {
23774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23775       };
23776     } catch (...) {
23777       {
23778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23779       };
23780     }
23781   }
23782
23783   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23784
23785
23786   return jresult;
23787 }
23788
23789
23790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23791   void * jresult ;
23792   Dali::PixelData *result = 0 ;
23793
23794   {
23795     try {
23796       result = (Dali::PixelData *)new Dali::PixelData();
23797     } catch (std::out_of_range& e) {
23798       {
23799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23800       };
23801     } catch (std::exception& e) {
23802       {
23803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23804       };
23805     } catch (Dali::DaliException e) {
23806       {
23807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23808       };
23809     } catch (...) {
23810       {
23811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23812       };
23813     }
23814   }
23815
23816   jresult = (void *)result;
23817   return jresult;
23818 }
23819
23820
23821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23822   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23823
23824   arg1 = (Dali::PixelData *)jarg1;
23825   {
23826     try {
23827       delete arg1;
23828     } catch (std::out_of_range& e) {
23829       {
23830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23831       };
23832     } catch (std::exception& e) {
23833       {
23834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23835       };
23836     } catch (Dali::DaliException e) {
23837       {
23838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23839       };
23840     } catch (...) {
23841       {
23842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23843       };
23844     }
23845   }
23846
23847 }
23848
23849
23850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23851   void * jresult ;
23852   Dali::PixelData *arg1 = 0 ;
23853   Dali::PixelData *result = 0 ;
23854
23855   arg1 = (Dali::PixelData *)jarg1;
23856   if (!arg1) {
23857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23858     return 0;
23859   }
23860   {
23861     try {
23862       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23863     } catch (std::out_of_range& e) {
23864       {
23865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23866       };
23867     } catch (std::exception& e) {
23868       {
23869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23870       };
23871     } catch (Dali::DaliException e) {
23872       {
23873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23874       };
23875     } catch (...) {
23876       {
23877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23878       };
23879     }
23880   }
23881
23882   jresult = (void *)result;
23883   return jresult;
23884 }
23885
23886
23887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23888   void * jresult ;
23889   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23890   Dali::PixelData *arg2 = 0 ;
23891   Dali::PixelData *result = 0 ;
23892
23893   arg1 = (Dali::PixelData *)jarg1;
23894   arg2 = (Dali::PixelData *)jarg2;
23895   if (!arg2) {
23896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23897     return 0;
23898   }
23899   {
23900     try {
23901       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
23902     } catch (std::out_of_range& e) {
23903       {
23904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23905       };
23906     } catch (std::exception& e) {
23907       {
23908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23909       };
23910     } catch (Dali::DaliException e) {
23911       {
23912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23913       };
23914     } catch (...) {
23915       {
23916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23917       };
23918     }
23919   }
23920
23921   jresult = (void *)result;
23922   return jresult;
23923 }
23924
23925
23926 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
23927   unsigned int jresult ;
23928   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23929   unsigned int result;
23930
23931   arg1 = (Dali::PixelData *)jarg1;
23932   {
23933     try {
23934       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
23935     } catch (std::out_of_range& e) {
23936       {
23937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23938       };
23939     } catch (std::exception& e) {
23940       {
23941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23942       };
23943     } catch (Dali::DaliException e) {
23944       {
23945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23946       };
23947     } catch (...) {
23948       {
23949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23950       };
23951     }
23952   }
23953
23954   jresult = result;
23955   return jresult;
23956 }
23957
23958
23959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
23960   unsigned int jresult ;
23961   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23962   unsigned int result;
23963
23964   arg1 = (Dali::PixelData *)jarg1;
23965   {
23966     try {
23967       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
23968     } catch (std::out_of_range& e) {
23969       {
23970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23971       };
23972     } catch (std::exception& e) {
23973       {
23974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23975       };
23976     } catch (Dali::DaliException e) {
23977       {
23978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23979       };
23980     } catch (...) {
23981       {
23982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23983       };
23984     }
23985   }
23986
23987   jresult = result;
23988   return jresult;
23989 }
23990
23991
23992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
23993   int jresult ;
23994   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23995   Dali::Pixel::Format result;
23996
23997   arg1 = (Dali::PixelData *)jarg1;
23998   {
23999     try {
24000       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24001     } catch (std::out_of_range& e) {
24002       {
24003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24004       };
24005     } catch (std::exception& e) {
24006       {
24007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24008       };
24009     } catch (Dali::DaliException e) {
24010       {
24011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24012       };
24013     } catch (...) {
24014       {
24015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24016       };
24017     }
24018   }
24019
24020   jresult = (int)result;
24021   return jresult;
24022 }
24023
24024
24025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24026   unsigned int jresult ;
24027   unsigned int result;
24028
24029   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24030   jresult = result;
24031   return jresult;
24032 }
24033
24034
24035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24036   unsigned int jresult ;
24037   unsigned int result;
24038
24039   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24040   jresult = result;
24041   return jresult;
24042 }
24043
24044
24045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24046   unsigned int jresult ;
24047   unsigned int result;
24048
24049   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24050   jresult = result;
24051   return jresult;
24052 }
24053
24054
24055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24056   unsigned int jresult ;
24057   unsigned int result;
24058
24059   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24060   jresult = result;
24061   return jresult;
24062 }
24063
24064
24065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24066   unsigned int jresult ;
24067   unsigned int result;
24068
24069   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24070   jresult = result;
24071   return jresult;
24072 }
24073
24074
24075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24076   unsigned int jresult ;
24077   unsigned int result;
24078
24079   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24080   jresult = result;
24081   return jresult;
24082 }
24083
24084
24085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24086   void * jresult ;
24087   Dali::TextureType::Type arg1 ;
24088   Dali::Pixel::Format arg2 ;
24089   unsigned int arg3 ;
24090   unsigned int arg4 ;
24091   Dali::Texture result;
24092
24093   arg1 = (Dali::TextureType::Type)jarg1;
24094   arg2 = (Dali::Pixel::Format)jarg2;
24095   arg3 = (unsigned int)jarg3;
24096   arg4 = (unsigned int)jarg4;
24097   {
24098     try {
24099       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24100     } catch (std::out_of_range& e) {
24101       {
24102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24103       };
24104     } catch (std::exception& e) {
24105       {
24106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24107       };
24108     } catch (Dali::DaliException e) {
24109       {
24110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24111       };
24112     } catch (...) {
24113       {
24114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24115       };
24116     }
24117   }
24118
24119   jresult = new Dali::Texture((const Dali::Texture &)result);
24120   return jresult;
24121 }
24122
24123
24124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24125   void * jresult ;
24126   NativeImageInterface *arg1 = 0 ;
24127   Dali::Texture result;
24128
24129   arg1 = (NativeImageInterface *)jarg1;
24130   if (!arg1) {
24131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24132     return 0;
24133   }
24134   {
24135     try {
24136       result = Dali::Texture::New(*arg1);
24137     } catch (std::out_of_range& e) {
24138       {
24139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24140       };
24141     } catch (std::exception& e) {
24142       {
24143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24144       };
24145     } catch (Dali::DaliException e) {
24146       {
24147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24148       };
24149     } catch (...) {
24150       {
24151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24152       };
24153     }
24154   }
24155
24156   jresult = new Dali::Texture((const Dali::Texture &)result);
24157   return jresult;
24158 }
24159
24160
24161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24162   void * jresult ;
24163   Dali::Texture *result = 0 ;
24164
24165   {
24166     try {
24167       result = (Dali::Texture *)new Dali::Texture();
24168     } catch (std::out_of_range& e) {
24169       {
24170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24171       };
24172     } catch (std::exception& e) {
24173       {
24174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24175       };
24176     } catch (Dali::DaliException e) {
24177       {
24178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24179       };
24180     } catch (...) {
24181       {
24182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24183       };
24184     }
24185   }
24186
24187   jresult = (void *)result;
24188   return jresult;
24189 }
24190
24191
24192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24193   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24194
24195   arg1 = (Dali::Texture *)jarg1;
24196   {
24197     try {
24198       delete arg1;
24199     } catch (std::out_of_range& e) {
24200       {
24201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24202       };
24203     } catch (std::exception& e) {
24204       {
24205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24206       };
24207     } catch (Dali::DaliException e) {
24208       {
24209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24210       };
24211     } catch (...) {
24212       {
24213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24214       };
24215     }
24216   }
24217
24218 }
24219
24220
24221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24222   void * jresult ;
24223   Dali::Texture *arg1 = 0 ;
24224   Dali::Texture *result = 0 ;
24225
24226   arg1 = (Dali::Texture *)jarg1;
24227   if (!arg1) {
24228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24229     return 0;
24230   }
24231   {
24232     try {
24233       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24234     } catch (std::out_of_range& e) {
24235       {
24236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24237       };
24238     } catch (std::exception& e) {
24239       {
24240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24241       };
24242     } catch (Dali::DaliException e) {
24243       {
24244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24245       };
24246     } catch (...) {
24247       {
24248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24249       };
24250     }
24251   }
24252
24253   jresult = (void *)result;
24254   return jresult;
24255 }
24256
24257
24258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24259   void * jresult ;
24260   Dali::BaseHandle arg1 ;
24261   Dali::BaseHandle *argp1 ;
24262   Dali::Texture result;
24263
24264   argp1 = (Dali::BaseHandle *)jarg1;
24265   if (!argp1) {
24266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24267     return 0;
24268   }
24269   arg1 = *argp1;
24270   {
24271     try {
24272       result = Dali::Texture::DownCast(arg1);
24273     } catch (std::out_of_range& e) {
24274       {
24275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24276       };
24277     } catch (std::exception& e) {
24278       {
24279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24280       };
24281     } catch (Dali::DaliException e) {
24282       {
24283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24284       };
24285     } catch (...) {
24286       {
24287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24288       };
24289     }
24290   }
24291
24292   jresult = new Dali::Texture((const Dali::Texture &)result);
24293   return jresult;
24294 }
24295
24296
24297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24298   void * jresult ;
24299   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24300   Dali::Texture *arg2 = 0 ;
24301   Dali::Texture *result = 0 ;
24302
24303   arg1 = (Dali::Texture *)jarg1;
24304   arg2 = (Dali::Texture *)jarg2;
24305   if (!arg2) {
24306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24307     return 0;
24308   }
24309   {
24310     try {
24311       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24312     } catch (std::out_of_range& e) {
24313       {
24314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24315       };
24316     } catch (std::exception& e) {
24317       {
24318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24319       };
24320     } catch (Dali::DaliException e) {
24321       {
24322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24323       };
24324     } catch (...) {
24325       {
24326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24327       };
24328     }
24329   }
24330
24331   jresult = (void *)result;
24332   return jresult;
24333 }
24334
24335
24336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24337   unsigned int jresult ;
24338   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24339   Dali::PixelData arg2 ;
24340   Dali::PixelData *argp2 ;
24341   bool result;
24342
24343   arg1 = (Dali::Texture *)jarg1;
24344   argp2 = (Dali::PixelData *)jarg2;
24345   if (!argp2) {
24346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24347     return 0;
24348   }
24349   arg2 = *argp2;
24350   {
24351     try {
24352       result = (bool)(arg1)->Upload(arg2);
24353     } catch (std::out_of_range& e) {
24354       {
24355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24356       };
24357     } catch (std::exception& e) {
24358       {
24359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24360       };
24361     } catch (Dali::DaliException e) {
24362       {
24363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24364       };
24365     } catch (...) {
24366       {
24367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24368       };
24369     }
24370   }
24371
24372   jresult = result;
24373   return jresult;
24374 }
24375
24376
24377 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) {
24378   unsigned int jresult ;
24379   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24380   Dali::PixelData arg2 ;
24381   unsigned int arg3 ;
24382   unsigned int arg4 ;
24383   unsigned int arg5 ;
24384   unsigned int arg6 ;
24385   unsigned int arg7 ;
24386   unsigned int arg8 ;
24387   Dali::PixelData *argp2 ;
24388   bool result;
24389
24390   arg1 = (Dali::Texture *)jarg1;
24391   argp2 = (Dali::PixelData *)jarg2;
24392   if (!argp2) {
24393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24394     return 0;
24395   }
24396   arg2 = *argp2;
24397   arg3 = (unsigned int)jarg3;
24398   arg4 = (unsigned int)jarg4;
24399   arg5 = (unsigned int)jarg5;
24400   arg6 = (unsigned int)jarg6;
24401   arg7 = (unsigned int)jarg7;
24402   arg8 = (unsigned int)jarg8;
24403   {
24404     try {
24405       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24406     } catch (std::out_of_range& e) {
24407       {
24408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24409       };
24410     } catch (std::exception& e) {
24411       {
24412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24413       };
24414     } catch (Dali::DaliException e) {
24415       {
24416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24417       };
24418     } catch (...) {
24419       {
24420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24421       };
24422     }
24423   }
24424
24425   jresult = result;
24426   return jresult;
24427 }
24428
24429
24430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24431   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24432
24433   arg1 = (Dali::Texture *)jarg1;
24434   {
24435     try {
24436       (arg1)->GenerateMipmaps();
24437     } catch (std::out_of_range& e) {
24438       {
24439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24440       };
24441     } catch (std::exception& e) {
24442       {
24443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24444       };
24445     } catch (Dali::DaliException e) {
24446       {
24447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24448       };
24449     } catch (...) {
24450       {
24451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24452       };
24453     }
24454   }
24455
24456 }
24457
24458
24459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24460   unsigned int jresult ;
24461   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24462   unsigned int result;
24463
24464   arg1 = (Dali::Texture *)jarg1;
24465   {
24466     try {
24467       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24468     } catch (std::out_of_range& e) {
24469       {
24470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24471       };
24472     } catch (std::exception& e) {
24473       {
24474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24475       };
24476     } catch (Dali::DaliException e) {
24477       {
24478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24479       };
24480     } catch (...) {
24481       {
24482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24483       };
24484     }
24485   }
24486
24487   jresult = result;
24488   return jresult;
24489 }
24490
24491
24492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24493   unsigned int jresult ;
24494   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24495   unsigned int result;
24496
24497   arg1 = (Dali::Texture *)jarg1;
24498   {
24499     try {
24500       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24501     } catch (std::out_of_range& e) {
24502       {
24503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24504       };
24505     } catch (std::exception& e) {
24506       {
24507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24508       };
24509     } catch (Dali::DaliException e) {
24510       {
24511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24512       };
24513     } catch (...) {
24514       {
24515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24516       };
24517     }
24518   }
24519
24520   jresult = result;
24521   return jresult;
24522 }
24523
24524
24525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24526   void * jresult ;
24527   Dali::Sampler result;
24528
24529   {
24530     try {
24531       result = Dali::Sampler::New();
24532     } catch (std::out_of_range& e) {
24533       {
24534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24535       };
24536     } catch (std::exception& e) {
24537       {
24538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24539       };
24540     } catch (Dali::DaliException e) {
24541       {
24542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24543       };
24544     } catch (...) {
24545       {
24546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24547       };
24548     }
24549   }
24550
24551   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24552   return jresult;
24553 }
24554
24555
24556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24557   void * jresult ;
24558   Dali::Sampler *result = 0 ;
24559
24560   {
24561     try {
24562       result = (Dali::Sampler *)new Dali::Sampler();
24563     } catch (std::out_of_range& e) {
24564       {
24565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24566       };
24567     } catch (std::exception& e) {
24568       {
24569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24570       };
24571     } catch (Dali::DaliException e) {
24572       {
24573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24574       };
24575     } catch (...) {
24576       {
24577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24578       };
24579     }
24580   }
24581
24582   jresult = (void *)result;
24583   return jresult;
24584 }
24585
24586
24587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24588   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24589
24590   arg1 = (Dali::Sampler *)jarg1;
24591   {
24592     try {
24593       delete arg1;
24594     } catch (std::out_of_range& e) {
24595       {
24596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24597       };
24598     } catch (std::exception& e) {
24599       {
24600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24601       };
24602     } catch (Dali::DaliException e) {
24603       {
24604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24605       };
24606     } catch (...) {
24607       {
24608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24609       };
24610     }
24611   }
24612
24613 }
24614
24615
24616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24617   void * jresult ;
24618   Dali::Sampler *arg1 = 0 ;
24619   Dali::Sampler *result = 0 ;
24620
24621   arg1 = (Dali::Sampler *)jarg1;
24622   if (!arg1) {
24623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24624     return 0;
24625   }
24626   {
24627     try {
24628       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24629     } catch (std::out_of_range& e) {
24630       {
24631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24632       };
24633     } catch (std::exception& e) {
24634       {
24635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24636       };
24637     } catch (Dali::DaliException e) {
24638       {
24639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24640       };
24641     } catch (...) {
24642       {
24643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24644       };
24645     }
24646   }
24647
24648   jresult = (void *)result;
24649   return jresult;
24650 }
24651
24652
24653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24654   void * jresult ;
24655   Dali::BaseHandle arg1 ;
24656   Dali::BaseHandle *argp1 ;
24657   Dali::Sampler result;
24658
24659   argp1 = (Dali::BaseHandle *)jarg1;
24660   if (!argp1) {
24661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24662     return 0;
24663   }
24664   arg1 = *argp1;
24665   {
24666     try {
24667       result = Dali::Sampler::DownCast(arg1);
24668     } catch (std::out_of_range& e) {
24669       {
24670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24671       };
24672     } catch (std::exception& e) {
24673       {
24674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24675       };
24676     } catch (Dali::DaliException e) {
24677       {
24678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24679       };
24680     } catch (...) {
24681       {
24682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24683       };
24684     }
24685   }
24686
24687   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24688   return jresult;
24689 }
24690
24691
24692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24693   void * jresult ;
24694   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24695   Dali::Sampler *arg2 = 0 ;
24696   Dali::Sampler *result = 0 ;
24697
24698   arg1 = (Dali::Sampler *)jarg1;
24699   arg2 = (Dali::Sampler *)jarg2;
24700   if (!arg2) {
24701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24702     return 0;
24703   }
24704   {
24705     try {
24706       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24707     } catch (std::out_of_range& e) {
24708       {
24709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24710       };
24711     } catch (std::exception& e) {
24712       {
24713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24714       };
24715     } catch (Dali::DaliException e) {
24716       {
24717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24718       };
24719     } catch (...) {
24720       {
24721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24722       };
24723     }
24724   }
24725
24726   jresult = (void *)result;
24727   return jresult;
24728 }
24729
24730
24731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24732   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24733   Dali::FilterMode::Type arg2 ;
24734   Dali::FilterMode::Type arg3 ;
24735
24736   arg1 = (Dali::Sampler *)jarg1;
24737   arg2 = (Dali::FilterMode::Type)jarg2;
24738   arg3 = (Dali::FilterMode::Type)jarg3;
24739   {
24740     try {
24741       (arg1)->SetFilterMode(arg2,arg3);
24742     } catch (std::out_of_range& e) {
24743       {
24744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24745       };
24746     } catch (std::exception& e) {
24747       {
24748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24749       };
24750     } catch (Dali::DaliException e) {
24751       {
24752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24753       };
24754     } catch (...) {
24755       {
24756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24757       };
24758     }
24759   }
24760
24761 }
24762
24763
24764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24765   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24766   Dali::WrapMode::Type arg2 ;
24767   Dali::WrapMode::Type arg3 ;
24768
24769   arg1 = (Dali::Sampler *)jarg1;
24770   arg2 = (Dali::WrapMode::Type)jarg2;
24771   arg3 = (Dali::WrapMode::Type)jarg3;
24772   {
24773     try {
24774       (arg1)->SetWrapMode(arg2,arg3);
24775     } catch (std::out_of_range& e) {
24776       {
24777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24778       };
24779     } catch (std::exception& e) {
24780       {
24781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24782       };
24783     } catch (Dali::DaliException e) {
24784       {
24785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24786       };
24787     } catch (...) {
24788       {
24789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24790       };
24791     }
24792   }
24793
24794 }
24795
24796
24797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24798   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24799   Dali::WrapMode::Type arg2 ;
24800   Dali::WrapMode::Type arg3 ;
24801   Dali::WrapMode::Type arg4 ;
24802
24803   arg1 = (Dali::Sampler *)jarg1;
24804   arg2 = (Dali::WrapMode::Type)jarg2;
24805   arg3 = (Dali::WrapMode::Type)jarg3;
24806   arg4 = (Dali::WrapMode::Type)jarg4;
24807   {
24808     try {
24809       (arg1)->SetWrapMode(arg2,arg3,arg4);
24810     } catch (std::out_of_range& e) {
24811       {
24812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24813       };
24814     } catch (std::exception& e) {
24815       {
24816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24817       };
24818     } catch (Dali::DaliException e) {
24819       {
24820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24821       };
24822     } catch (...) {
24823       {
24824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24825       };
24826     }
24827   }
24828
24829 }
24830
24831
24832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24833   void * jresult ;
24834   Dali::TextureSet result;
24835
24836   {
24837     try {
24838       result = Dali::TextureSet::New();
24839     } catch (std::out_of_range& e) {
24840       {
24841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24842       };
24843     } catch (std::exception& e) {
24844       {
24845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24846       };
24847     } catch (Dali::DaliException e) {
24848       {
24849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24850       };
24851     } catch (...) {
24852       {
24853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24854       };
24855     }
24856   }
24857
24858   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24859   return jresult;
24860 }
24861
24862
24863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
24864   void * jresult ;
24865   Dali::TextureSet *result = 0 ;
24866
24867   {
24868     try {
24869       result = (Dali::TextureSet *)new Dali::TextureSet();
24870     } catch (std::out_of_range& e) {
24871       {
24872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24873       };
24874     } catch (std::exception& e) {
24875       {
24876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24877       };
24878     } catch (Dali::DaliException e) {
24879       {
24880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24881       };
24882     } catch (...) {
24883       {
24884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24885       };
24886     }
24887   }
24888
24889   jresult = (void *)result;
24890   return jresult;
24891 }
24892
24893
24894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
24895   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24896
24897   arg1 = (Dali::TextureSet *)jarg1;
24898   {
24899     try {
24900       delete arg1;
24901     } catch (std::out_of_range& e) {
24902       {
24903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24904       };
24905     } catch (std::exception& e) {
24906       {
24907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24908       };
24909     } catch (Dali::DaliException e) {
24910       {
24911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24912       };
24913     } catch (...) {
24914       {
24915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24916       };
24917     }
24918   }
24919
24920 }
24921
24922
24923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
24924   void * jresult ;
24925   Dali::TextureSet *arg1 = 0 ;
24926   Dali::TextureSet *result = 0 ;
24927
24928   arg1 = (Dali::TextureSet *)jarg1;
24929   if (!arg1) {
24930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24931     return 0;
24932   }
24933   {
24934     try {
24935       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
24936     } catch (std::out_of_range& e) {
24937       {
24938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24939       };
24940     } catch (std::exception& e) {
24941       {
24942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24943       };
24944     } catch (Dali::DaliException e) {
24945       {
24946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24947       };
24948     } catch (...) {
24949       {
24950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24951       };
24952     }
24953   }
24954
24955   jresult = (void *)result;
24956   return jresult;
24957 }
24958
24959
24960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
24961   void * jresult ;
24962   Dali::BaseHandle arg1 ;
24963   Dali::BaseHandle *argp1 ;
24964   Dali::TextureSet result;
24965
24966   argp1 = (Dali::BaseHandle *)jarg1;
24967   if (!argp1) {
24968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24969     return 0;
24970   }
24971   arg1 = *argp1;
24972   {
24973     try {
24974       result = Dali::TextureSet::DownCast(arg1);
24975     } catch (std::out_of_range& e) {
24976       {
24977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24978       };
24979     } catch (std::exception& e) {
24980       {
24981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24982       };
24983     } catch (Dali::DaliException e) {
24984       {
24985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24986       };
24987     } catch (...) {
24988       {
24989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24990       };
24991     }
24992   }
24993
24994   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24995   return jresult;
24996 }
24997
24998
24999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25000   void * jresult ;
25001   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25002   Dali::TextureSet *arg2 = 0 ;
25003   Dali::TextureSet *result = 0 ;
25004
25005   arg1 = (Dali::TextureSet *)jarg1;
25006   arg2 = (Dali::TextureSet *)jarg2;
25007   if (!arg2) {
25008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25009     return 0;
25010   }
25011   {
25012     try {
25013       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25014     } catch (std::out_of_range& e) {
25015       {
25016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25017       };
25018     } catch (std::exception& e) {
25019       {
25020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25021       };
25022     } catch (Dali::DaliException e) {
25023       {
25024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25025       };
25026     } catch (...) {
25027       {
25028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25029       };
25030     }
25031   }
25032
25033   jresult = (void *)result;
25034   return jresult;
25035 }
25036
25037
25038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25039   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25040   size_t arg2 ;
25041   Dali::Texture arg3 ;
25042   Dali::Texture *argp3 ;
25043
25044   arg1 = (Dali::TextureSet *)jarg1;
25045   arg2 = (size_t)jarg2;
25046   argp3 = (Dali::Texture *)jarg3;
25047   if (!argp3) {
25048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25049     return ;
25050   }
25051   arg3 = *argp3;
25052   {
25053     try {
25054       (arg1)->SetTexture(arg2,arg3);
25055     } catch (std::out_of_range& e) {
25056       {
25057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25058       };
25059     } catch (std::exception& e) {
25060       {
25061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25062       };
25063     } catch (Dali::DaliException e) {
25064       {
25065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25066       };
25067     } catch (...) {
25068       {
25069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25070       };
25071     }
25072   }
25073
25074 }
25075
25076
25077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25078   void * jresult ;
25079   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25080   size_t arg2 ;
25081   Dali::Texture result;
25082
25083   arg1 = (Dali::TextureSet *)jarg1;
25084   arg2 = (size_t)jarg2;
25085   {
25086     try {
25087       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25088     } catch (std::out_of_range& e) {
25089       {
25090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25091       };
25092     } catch (std::exception& e) {
25093       {
25094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25095       };
25096     } catch (Dali::DaliException e) {
25097       {
25098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25099       };
25100     } catch (...) {
25101       {
25102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25103       };
25104     }
25105   }
25106
25107   jresult = new Dali::Texture((const Dali::Texture &)result);
25108   return jresult;
25109 }
25110
25111
25112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25113   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25114   size_t arg2 ;
25115   Dali::Sampler arg3 ;
25116   Dali::Sampler *argp3 ;
25117
25118   arg1 = (Dali::TextureSet *)jarg1;
25119   arg2 = (size_t)jarg2;
25120   argp3 = (Dali::Sampler *)jarg3;
25121   if (!argp3) {
25122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25123     return ;
25124   }
25125   arg3 = *argp3;
25126   {
25127     try {
25128       (arg1)->SetSampler(arg2,arg3);
25129     } catch (std::out_of_range& e) {
25130       {
25131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25132       };
25133     } catch (std::exception& e) {
25134       {
25135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25136       };
25137     } catch (Dali::DaliException e) {
25138       {
25139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25140       };
25141     } catch (...) {
25142       {
25143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25144       };
25145     }
25146   }
25147
25148 }
25149
25150
25151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25152   void * jresult ;
25153   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25154   size_t arg2 ;
25155   Dali::Sampler result;
25156
25157   arg1 = (Dali::TextureSet *)jarg1;
25158   arg2 = (size_t)jarg2;
25159   {
25160     try {
25161       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25162     } catch (std::out_of_range& e) {
25163       {
25164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25165       };
25166     } catch (std::exception& e) {
25167       {
25168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25169       };
25170     } catch (Dali::DaliException e) {
25171       {
25172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25173       };
25174     } catch (...) {
25175       {
25176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25177       };
25178     }
25179   }
25180
25181   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25182   return jresult;
25183 }
25184
25185
25186 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25187   unsigned long jresult ;
25188   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25189   size_t result;
25190
25191   arg1 = (Dali::TextureSet *)jarg1;
25192   {
25193     try {
25194       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25195     } catch (std::out_of_range& e) {
25196       {
25197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25198       };
25199     } catch (std::exception& e) {
25200       {
25201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25202       };
25203     } catch (Dali::DaliException e) {
25204       {
25205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25206       };
25207     } catch (...) {
25208       {
25209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25210       };
25211     }
25212   }
25213
25214   jresult = (unsigned long)result;
25215   return jresult;
25216 }
25217
25218
25219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25220   void * jresult ;
25221   Dali::Property::Map *arg1 = 0 ;
25222   Dali::PropertyBuffer result;
25223
25224   arg1 = (Dali::Property::Map *)jarg1;
25225   if (!arg1) {
25226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25227     return 0;
25228   }
25229   {
25230     try {
25231       result = Dali::PropertyBuffer::New(*arg1);
25232     } catch (std::out_of_range& e) {
25233       {
25234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25235       };
25236     } catch (std::exception& e) {
25237       {
25238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25239       };
25240     } catch (Dali::DaliException e) {
25241       {
25242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25243       };
25244     } catch (...) {
25245       {
25246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25247       };
25248     }
25249   }
25250
25251   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25252   return jresult;
25253 }
25254
25255
25256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25257   void * jresult ;
25258   Dali::PropertyBuffer *result = 0 ;
25259
25260   {
25261     try {
25262       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25263     } catch (std::out_of_range& e) {
25264       {
25265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25266       };
25267     } catch (std::exception& e) {
25268       {
25269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25270       };
25271     } catch (Dali::DaliException e) {
25272       {
25273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25274       };
25275     } catch (...) {
25276       {
25277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25278       };
25279     }
25280   }
25281
25282   jresult = (void *)result;
25283   return jresult;
25284 }
25285
25286
25287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25288   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25289
25290   arg1 = (Dali::PropertyBuffer *)jarg1;
25291   {
25292     try {
25293       delete arg1;
25294     } catch (std::out_of_range& e) {
25295       {
25296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25297       };
25298     } catch (std::exception& e) {
25299       {
25300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25301       };
25302     } catch (Dali::DaliException e) {
25303       {
25304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25305       };
25306     } catch (...) {
25307       {
25308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25309       };
25310     }
25311   }
25312
25313 }
25314
25315
25316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25317   void * jresult ;
25318   Dali::PropertyBuffer *arg1 = 0 ;
25319   Dali::PropertyBuffer *result = 0 ;
25320
25321   arg1 = (Dali::PropertyBuffer *)jarg1;
25322   if (!arg1) {
25323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25324     return 0;
25325   }
25326   {
25327     try {
25328       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25329     } catch (std::out_of_range& e) {
25330       {
25331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25332       };
25333     } catch (std::exception& e) {
25334       {
25335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25336       };
25337     } catch (Dali::DaliException e) {
25338       {
25339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25340       };
25341     } catch (...) {
25342       {
25343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25344       };
25345     }
25346   }
25347
25348   jresult = (void *)result;
25349   return jresult;
25350 }
25351
25352
25353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25354   void * jresult ;
25355   Dali::BaseHandle arg1 ;
25356   Dali::BaseHandle *argp1 ;
25357   Dali::PropertyBuffer result;
25358
25359   argp1 = (Dali::BaseHandle *)jarg1;
25360   if (!argp1) {
25361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25362     return 0;
25363   }
25364   arg1 = *argp1;
25365   {
25366     try {
25367       result = Dali::PropertyBuffer::DownCast(arg1);
25368     } catch (std::out_of_range& e) {
25369       {
25370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25371       };
25372     } catch (std::exception& e) {
25373       {
25374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25375       };
25376     } catch (Dali::DaliException e) {
25377       {
25378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25379       };
25380     } catch (...) {
25381       {
25382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25383       };
25384     }
25385   }
25386
25387   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25388   return jresult;
25389 }
25390
25391
25392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25393   void * jresult ;
25394   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25395   Dali::PropertyBuffer *arg2 = 0 ;
25396   Dali::PropertyBuffer *result = 0 ;
25397
25398   arg1 = (Dali::PropertyBuffer *)jarg1;
25399   arg2 = (Dali::PropertyBuffer *)jarg2;
25400   if (!arg2) {
25401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25402     return 0;
25403   }
25404   {
25405     try {
25406       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25407     } catch (std::out_of_range& e) {
25408       {
25409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25410       };
25411     } catch (std::exception& e) {
25412       {
25413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25414       };
25415     } catch (Dali::DaliException e) {
25416       {
25417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25418       };
25419     } catch (...) {
25420       {
25421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25422       };
25423     }
25424   }
25425
25426   jresult = (void *)result;
25427   return jresult;
25428 }
25429
25430
25431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25432   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25433   void *arg2 = (void *) 0 ;
25434   std::size_t arg3 ;
25435
25436   arg1 = (Dali::PropertyBuffer *)jarg1;
25437   arg2 = jarg2;
25438   arg3 = (std::size_t)jarg3;
25439   {
25440     try {
25441       (arg1)->SetData((void const *)arg2,arg3);
25442     } catch (std::out_of_range& e) {
25443       {
25444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25445       };
25446     } catch (std::exception& e) {
25447       {
25448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25449       };
25450     } catch (Dali::DaliException e) {
25451       {
25452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25453       };
25454     } catch (...) {
25455       {
25456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25457       };
25458     }
25459   }
25460
25461 }
25462
25463
25464 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25465   unsigned long jresult ;
25466   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25467   std::size_t result;
25468
25469   arg1 = (Dali::PropertyBuffer *)jarg1;
25470   {
25471     try {
25472       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25473     } catch (std::out_of_range& e) {
25474       {
25475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25476       };
25477     } catch (std::exception& e) {
25478       {
25479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25480       };
25481     } catch (Dali::DaliException e) {
25482       {
25483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25484       };
25485     } catch (...) {
25486       {
25487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25488       };
25489     }
25490   }
25491
25492   jresult = (unsigned long)result;
25493   return jresult;
25494 }
25495
25496
25497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25498   void * jresult ;
25499   Dali::Geometry result;
25500
25501   {
25502     try {
25503       result = Dali::Geometry::New();
25504     } catch (std::out_of_range& e) {
25505       {
25506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25507       };
25508     } catch (std::exception& e) {
25509       {
25510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25511       };
25512     } catch (Dali::DaliException e) {
25513       {
25514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25515       };
25516     } catch (...) {
25517       {
25518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25519       };
25520     }
25521   }
25522
25523   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25524   return jresult;
25525 }
25526
25527
25528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25529   void * jresult ;
25530   Dali::Geometry *result = 0 ;
25531
25532   {
25533     try {
25534       result = (Dali::Geometry *)new Dali::Geometry();
25535     } catch (std::out_of_range& e) {
25536       {
25537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25538       };
25539     } catch (std::exception& e) {
25540       {
25541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25542       };
25543     } catch (Dali::DaliException e) {
25544       {
25545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25546       };
25547     } catch (...) {
25548       {
25549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25550       };
25551     }
25552   }
25553
25554   jresult = (void *)result;
25555   return jresult;
25556 }
25557
25558
25559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25560   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25561
25562   arg1 = (Dali::Geometry *)jarg1;
25563   {
25564     try {
25565       delete arg1;
25566     } catch (std::out_of_range& e) {
25567       {
25568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25569       };
25570     } catch (std::exception& e) {
25571       {
25572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25573       };
25574     } catch (Dali::DaliException e) {
25575       {
25576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25577       };
25578     } catch (...) {
25579       {
25580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25581       };
25582     }
25583   }
25584
25585 }
25586
25587
25588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25589   void * jresult ;
25590   Dali::Geometry *arg1 = 0 ;
25591   Dali::Geometry *result = 0 ;
25592
25593   arg1 = (Dali::Geometry *)jarg1;
25594   if (!arg1) {
25595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25596     return 0;
25597   }
25598   {
25599     try {
25600       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25601     } catch (std::out_of_range& e) {
25602       {
25603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25604       };
25605     } catch (std::exception& e) {
25606       {
25607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25608       };
25609     } catch (Dali::DaliException e) {
25610       {
25611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25612       };
25613     } catch (...) {
25614       {
25615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25616       };
25617     }
25618   }
25619
25620   jresult = (void *)result;
25621   return jresult;
25622 }
25623
25624
25625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25626   void * jresult ;
25627   Dali::BaseHandle arg1 ;
25628   Dali::BaseHandle *argp1 ;
25629   Dali::Geometry result;
25630
25631   argp1 = (Dali::BaseHandle *)jarg1;
25632   if (!argp1) {
25633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25634     return 0;
25635   }
25636   arg1 = *argp1;
25637   {
25638     try {
25639       result = Dali::Geometry::DownCast(arg1);
25640     } catch (std::out_of_range& e) {
25641       {
25642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25643       };
25644     } catch (std::exception& e) {
25645       {
25646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25647       };
25648     } catch (Dali::DaliException e) {
25649       {
25650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25651       };
25652     } catch (...) {
25653       {
25654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25655       };
25656     }
25657   }
25658
25659   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25660   return jresult;
25661 }
25662
25663
25664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25665   void * jresult ;
25666   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25667   Dali::Geometry *arg2 = 0 ;
25668   Dali::Geometry *result = 0 ;
25669
25670   arg1 = (Dali::Geometry *)jarg1;
25671   arg2 = (Dali::Geometry *)jarg2;
25672   if (!arg2) {
25673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25674     return 0;
25675   }
25676   {
25677     try {
25678       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25679     } catch (std::out_of_range& e) {
25680       {
25681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25682       };
25683     } catch (std::exception& e) {
25684       {
25685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25686       };
25687     } catch (Dali::DaliException e) {
25688       {
25689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25690       };
25691     } catch (...) {
25692       {
25693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25694       };
25695     }
25696   }
25697
25698   jresult = (void *)result;
25699   return jresult;
25700 }
25701
25702
25703 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25704   unsigned long jresult ;
25705   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25706   Dali::PropertyBuffer *arg2 = 0 ;
25707   std::size_t result;
25708
25709   arg1 = (Dali::Geometry *)jarg1;
25710   arg2 = (Dali::PropertyBuffer *)jarg2;
25711   if (!arg2) {
25712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25713     return 0;
25714   }
25715   {
25716     try {
25717       result = (arg1)->AddVertexBuffer(*arg2);
25718     } catch (std::out_of_range& e) {
25719       {
25720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25721       };
25722     } catch (std::exception& e) {
25723       {
25724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25725       };
25726     } catch (Dali::DaliException e) {
25727       {
25728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25729       };
25730     } catch (...) {
25731       {
25732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25733       };
25734     }
25735   }
25736
25737   jresult = (unsigned long)result;
25738   return jresult;
25739 }
25740
25741
25742 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25743   unsigned long jresult ;
25744   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25745   std::size_t result;
25746
25747   arg1 = (Dali::Geometry *)jarg1;
25748   {
25749     try {
25750       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25751     } catch (std::out_of_range& e) {
25752       {
25753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25754       };
25755     } catch (std::exception& e) {
25756       {
25757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25758       };
25759     } catch (Dali::DaliException e) {
25760       {
25761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25762       };
25763     } catch (...) {
25764       {
25765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25766       };
25767     }
25768   }
25769
25770   jresult = (unsigned long)result;
25771   return jresult;
25772 }
25773
25774
25775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25776   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25777   std::size_t arg2 ;
25778
25779   arg1 = (Dali::Geometry *)jarg1;
25780   arg2 = (std::size_t)jarg2;
25781   {
25782     try {
25783       (arg1)->RemoveVertexBuffer(arg2);
25784     } catch (std::out_of_range& e) {
25785       {
25786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25787       };
25788     } catch (std::exception& e) {
25789       {
25790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25791       };
25792     } catch (Dali::DaliException e) {
25793       {
25794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25795       };
25796     } catch (...) {
25797       {
25798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25799       };
25800     }
25801   }
25802
25803 }
25804
25805
25806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25807   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25808   unsigned short *arg2 = (unsigned short *) 0 ;
25809   size_t arg3 ;
25810
25811   arg1 = (Dali::Geometry *)jarg1;
25812   arg2 = jarg2;
25813   arg3 = (size_t)jarg3;
25814   {
25815     try {
25816       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25817     } catch (std::out_of_range& e) {
25818       {
25819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25820       };
25821     } catch (std::exception& e) {
25822       {
25823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25824       };
25825     } catch (Dali::DaliException e) {
25826       {
25827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25828       };
25829     } catch (...) {
25830       {
25831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25832       };
25833     }
25834   }
25835
25836
25837
25838 }
25839
25840
25841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25842   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25843   Dali::Geometry::Type arg2 ;
25844
25845   arg1 = (Dali::Geometry *)jarg1;
25846   arg2 = (Dali::Geometry::Type)jarg2;
25847   {
25848     try {
25849       (arg1)->SetType(arg2);
25850     } catch (std::out_of_range& e) {
25851       {
25852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25853       };
25854     } catch (std::exception& e) {
25855       {
25856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25857       };
25858     } catch (Dali::DaliException e) {
25859       {
25860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25861       };
25862     } catch (...) {
25863       {
25864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25865       };
25866     }
25867   }
25868
25869 }
25870
25871
25872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
25873   int jresult ;
25874   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25875   Dali::Geometry::Type result;
25876
25877   arg1 = (Dali::Geometry *)jarg1;
25878   {
25879     try {
25880       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
25881     } catch (std::out_of_range& e) {
25882       {
25883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25884       };
25885     } catch (std::exception& e) {
25886       {
25887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25888       };
25889     } catch (Dali::DaliException e) {
25890       {
25891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25892       };
25893     } catch (...) {
25894       {
25895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25896       };
25897     }
25898   }
25899
25900   jresult = (int)result;
25901   return jresult;
25902 }
25903
25904
25905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
25906   void * jresult ;
25907   Dali::Shader::Hint *result = 0 ;
25908
25909   {
25910     try {
25911       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
25912     } catch (std::out_of_range& e) {
25913       {
25914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25915       };
25916     } catch (std::exception& e) {
25917       {
25918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25919       };
25920     } catch (Dali::DaliException e) {
25921       {
25922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25923       };
25924     } catch (...) {
25925       {
25926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25927       };
25928     }
25929   }
25930
25931   jresult = (void *)result;
25932   return jresult;
25933 }
25934
25935
25936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
25937   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
25938
25939   arg1 = (Dali::Shader::Hint *)jarg1;
25940   {
25941     try {
25942       delete arg1;
25943     } catch (std::out_of_range& e) {
25944       {
25945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25946       };
25947     } catch (std::exception& e) {
25948       {
25949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25950       };
25951     } catch (Dali::DaliException e) {
25952       {
25953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25954       };
25955     } catch (...) {
25956       {
25957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25958       };
25959     }
25960   }
25961
25962 }
25963
25964
25965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
25966   int jresult ;
25967   int result;
25968
25969   result = (int)Dali::Shader::Property::PROGRAM;
25970   jresult = (int)result;
25971   return jresult;
25972 }
25973
25974
25975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
25976   void * jresult ;
25977   Dali::Shader::Property *result = 0 ;
25978
25979   {
25980     try {
25981       result = (Dali::Shader::Property *)new Dali::Shader::Property();
25982     } catch (std::out_of_range& e) {
25983       {
25984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25985       };
25986     } catch (std::exception& e) {
25987       {
25988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25989       };
25990     } catch (Dali::DaliException e) {
25991       {
25992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25993       };
25994     } catch (...) {
25995       {
25996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25997       };
25998     }
25999   }
26000
26001   jresult = (void *)result;
26002   return jresult;
26003 }
26004
26005
26006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26007   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26008
26009   arg1 = (Dali::Shader::Property *)jarg1;
26010   {
26011     try {
26012       delete arg1;
26013     } catch (std::out_of_range& e) {
26014       {
26015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26016       };
26017     } catch (std::exception& e) {
26018       {
26019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26020       };
26021     } catch (Dali::DaliException e) {
26022       {
26023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26024       };
26025     } catch (...) {
26026       {
26027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26028       };
26029     }
26030   }
26031
26032 }
26033
26034
26035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26036   void * jresult ;
26037   std::string *arg1 = 0 ;
26038   std::string *arg2 = 0 ;
26039   Dali::Shader::Hint::Value arg3 ;
26040   Dali::Shader result;
26041
26042   if (!jarg1) {
26043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26044     return 0;
26045   }
26046   std::string arg1_str(jarg1);
26047   arg1 = &arg1_str;
26048   if (!jarg2) {
26049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26050     return 0;
26051   }
26052   std::string arg2_str(jarg2);
26053   arg2 = &arg2_str;
26054   arg3 = (Dali::Shader::Hint::Value)jarg3;
26055   {
26056     try {
26057       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26058     } catch (std::out_of_range& e) {
26059       {
26060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26061       };
26062     } catch (std::exception& e) {
26063       {
26064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26065       };
26066     } catch (Dali::DaliException e) {
26067       {
26068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26069       };
26070     } catch (...) {
26071       {
26072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26073       };
26074     }
26075   }
26076
26077   jresult = new Dali::Shader((const Dali::Shader &)result);
26078
26079   //argout typemap for const std::string&
26080
26081
26082   //argout typemap for const std::string&
26083
26084   return jresult;
26085 }
26086
26087
26088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26089   void * jresult ;
26090   std::string *arg1 = 0 ;
26091   std::string *arg2 = 0 ;
26092   Dali::Shader result;
26093
26094   if (!jarg1) {
26095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26096     return 0;
26097   }
26098   std::string arg1_str(jarg1);
26099   arg1 = &arg1_str;
26100   if (!jarg2) {
26101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26102     return 0;
26103   }
26104   std::string arg2_str(jarg2);
26105   arg2 = &arg2_str;
26106   {
26107     try {
26108       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26109     } catch (std::out_of_range& e) {
26110       {
26111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26112       };
26113     } catch (std::exception& e) {
26114       {
26115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26116       };
26117     } catch (Dali::DaliException e) {
26118       {
26119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26120       };
26121     } catch (...) {
26122       {
26123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26124       };
26125     }
26126   }
26127
26128   jresult = new Dali::Shader((const Dali::Shader &)result);
26129
26130   //argout typemap for const std::string&
26131
26132
26133   //argout typemap for const std::string&
26134
26135   return jresult;
26136 }
26137
26138
26139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26140   void * jresult ;
26141   Dali::Shader *result = 0 ;
26142
26143   {
26144     try {
26145       result = (Dali::Shader *)new Dali::Shader();
26146     } catch (std::out_of_range& e) {
26147       {
26148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26149       };
26150     } catch (std::exception& e) {
26151       {
26152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26153       };
26154     } catch (Dali::DaliException e) {
26155       {
26156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26157       };
26158     } catch (...) {
26159       {
26160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26161       };
26162     }
26163   }
26164
26165   jresult = (void *)result;
26166   return jresult;
26167 }
26168
26169
26170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26171   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26172
26173   arg1 = (Dali::Shader *)jarg1;
26174   {
26175     try {
26176       delete arg1;
26177     } catch (std::out_of_range& e) {
26178       {
26179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26180       };
26181     } catch (std::exception& e) {
26182       {
26183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26184       };
26185     } catch (Dali::DaliException e) {
26186       {
26187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26188       };
26189     } catch (...) {
26190       {
26191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26192       };
26193     }
26194   }
26195
26196 }
26197
26198
26199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26200   void * jresult ;
26201   Dali::Shader *arg1 = 0 ;
26202   Dali::Shader *result = 0 ;
26203
26204   arg1 = (Dali::Shader *)jarg1;
26205   if (!arg1) {
26206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26207     return 0;
26208   }
26209   {
26210     try {
26211       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26212     } catch (std::out_of_range& e) {
26213       {
26214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26215       };
26216     } catch (std::exception& e) {
26217       {
26218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26219       };
26220     } catch (Dali::DaliException e) {
26221       {
26222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26223       };
26224     } catch (...) {
26225       {
26226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26227       };
26228     }
26229   }
26230
26231   jresult = (void *)result;
26232   return jresult;
26233 }
26234
26235
26236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26237   void * jresult ;
26238   Dali::BaseHandle arg1 ;
26239   Dali::BaseHandle *argp1 ;
26240   Dali::Shader result;
26241
26242   argp1 = (Dali::BaseHandle *)jarg1;
26243   if (!argp1) {
26244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26245     return 0;
26246   }
26247   arg1 = *argp1;
26248   {
26249     try {
26250       result = Dali::Shader::DownCast(arg1);
26251     } catch (std::out_of_range& e) {
26252       {
26253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26254       };
26255     } catch (std::exception& e) {
26256       {
26257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26258       };
26259     } catch (Dali::DaliException e) {
26260       {
26261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26262       };
26263     } catch (...) {
26264       {
26265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26266       };
26267     }
26268   }
26269
26270   jresult = new Dali::Shader((const Dali::Shader &)result);
26271   return jresult;
26272 }
26273
26274
26275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26276   void * jresult ;
26277   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26278   Dali::Shader *arg2 = 0 ;
26279   Dali::Shader *result = 0 ;
26280
26281   arg1 = (Dali::Shader *)jarg1;
26282   arg2 = (Dali::Shader *)jarg2;
26283   if (!arg2) {
26284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26285     return 0;
26286   }
26287   {
26288     try {
26289       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26290     } catch (std::out_of_range& e) {
26291       {
26292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26293       };
26294     } catch (std::exception& e) {
26295       {
26296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26297       };
26298     } catch (Dali::DaliException e) {
26299       {
26300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26301       };
26302     } catch (...) {
26303       {
26304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26305       };
26306     }
26307   }
26308
26309   jresult = (void *)result;
26310   return jresult;
26311 }
26312
26313
26314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26315   int jresult ;
26316   int result;
26317
26318   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26319   jresult = (int)result;
26320   return jresult;
26321 }
26322
26323
26324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26325   int jresult ;
26326   int result;
26327
26328   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26329   jresult = (int)result;
26330   return jresult;
26331 }
26332
26333
26334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26335   int jresult ;
26336   int result;
26337
26338   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26339   jresult = (int)result;
26340   return jresult;
26341 }
26342
26343
26344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26345   int jresult ;
26346   int result;
26347
26348   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26349   jresult = (int)result;
26350   return jresult;
26351 }
26352
26353
26354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26355   int jresult ;
26356   int result;
26357
26358   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26359   jresult = (int)result;
26360   return jresult;
26361 }
26362
26363
26364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26365   int jresult ;
26366   int result;
26367
26368   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26369   jresult = (int)result;
26370   return jresult;
26371 }
26372
26373
26374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26375   int jresult ;
26376   int result;
26377
26378   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26379   jresult = (int)result;
26380   return jresult;
26381 }
26382
26383
26384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26385   int jresult ;
26386   int result;
26387
26388   result = (int)Dali::Renderer::Property::BLEND_MODE;
26389   jresult = (int)result;
26390   return jresult;
26391 }
26392
26393
26394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26395   int jresult ;
26396   int result;
26397
26398   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26399   jresult = (int)result;
26400   return jresult;
26401 }
26402
26403
26404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26405   int jresult ;
26406   int result;
26407
26408   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26409   jresult = (int)result;
26410   return jresult;
26411 }
26412
26413
26414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26415   int jresult ;
26416   int result;
26417
26418   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26419   jresult = (int)result;
26420   return jresult;
26421 }
26422
26423
26424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26425   int jresult ;
26426   int result;
26427
26428   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26429   jresult = (int)result;
26430   return jresult;
26431 }
26432
26433
26434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26435   int jresult ;
26436   int result;
26437
26438   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26439   jresult = (int)result;
26440   return jresult;
26441 }
26442
26443
26444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26445   int jresult ;
26446   int result;
26447
26448   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26449   jresult = (int)result;
26450   return jresult;
26451 }
26452
26453
26454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26455   int jresult ;
26456   int result;
26457
26458   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26459   jresult = (int)result;
26460   return jresult;
26461 }
26462
26463
26464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26465   int jresult ;
26466   int result;
26467
26468   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26469   jresult = (int)result;
26470   return jresult;
26471 }
26472
26473
26474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26475   int jresult ;
26476   int result;
26477
26478   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26479   jresult = (int)result;
26480   return jresult;
26481 }
26482
26483
26484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26485   int jresult ;
26486   int result;
26487
26488   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26489   jresult = (int)result;
26490   return jresult;
26491 }
26492
26493
26494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26495   int jresult ;
26496   int result;
26497
26498   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26499   jresult = (int)result;
26500   return jresult;
26501 }
26502
26503
26504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26505   int jresult ;
26506   int result;
26507
26508   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26509   jresult = (int)result;
26510   return jresult;
26511 }
26512
26513
26514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26515   int jresult ;
26516   int result;
26517
26518   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26519   jresult = (int)result;
26520   return jresult;
26521 }
26522
26523
26524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26525   int jresult ;
26526   int result;
26527
26528   result = (int)Dali::Renderer::Property::RENDER_MODE;
26529   jresult = (int)result;
26530   return jresult;
26531 }
26532
26533
26534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26535   int jresult ;
26536   int result;
26537
26538   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26539   jresult = (int)result;
26540   return jresult;
26541 }
26542
26543
26544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26545   int jresult ;
26546   int result;
26547
26548   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26549   jresult = (int)result;
26550   return jresult;
26551 }
26552
26553
26554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26555   int jresult ;
26556   int result;
26557
26558   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26559   jresult = (int)result;
26560   return jresult;
26561 }
26562
26563
26564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26565   int jresult ;
26566   int result;
26567
26568   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26569   jresult = (int)result;
26570   return jresult;
26571 }
26572
26573
26574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26575   int jresult ;
26576   int result;
26577
26578   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26579   jresult = (int)result;
26580   return jresult;
26581 }
26582
26583
26584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26585   int jresult ;
26586   int result;
26587
26588   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26589   jresult = (int)result;
26590   return jresult;
26591 }
26592
26593
26594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26595   int jresult ;
26596   int result;
26597
26598   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26599   jresult = (int)result;
26600   return jresult;
26601 }
26602
26603
26604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26605   void * jresult ;
26606   Dali::Renderer::Property *result = 0 ;
26607
26608   {
26609     try {
26610       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26611     } catch (std::out_of_range& e) {
26612       {
26613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26614       };
26615     } catch (std::exception& e) {
26616       {
26617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26618       };
26619     } catch (Dali::DaliException e) {
26620       {
26621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26622       };
26623     } catch (...) {
26624       {
26625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26626       };
26627     }
26628   }
26629
26630   jresult = (void *)result;
26631   return jresult;
26632 }
26633
26634
26635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26636   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26637
26638   arg1 = (Dali::Renderer::Property *)jarg1;
26639   {
26640     try {
26641       delete arg1;
26642     } catch (std::out_of_range& e) {
26643       {
26644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26645       };
26646     } catch (std::exception& e) {
26647       {
26648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26649       };
26650     } catch (Dali::DaliException e) {
26651       {
26652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26653       };
26654     } catch (...) {
26655       {
26656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26657       };
26658     }
26659   }
26660
26661 }
26662
26663
26664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26665   void * jresult ;
26666   Dali::Geometry *arg1 = 0 ;
26667   Dali::Shader *arg2 = 0 ;
26668   Dali::Renderer result;
26669
26670   arg1 = (Dali::Geometry *)jarg1;
26671   if (!arg1) {
26672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26673     return 0;
26674   }
26675   arg2 = (Dali::Shader *)jarg2;
26676   if (!arg2) {
26677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26678     return 0;
26679   }
26680   {
26681     try {
26682       result = Dali::Renderer::New(*arg1,*arg2);
26683     } catch (std::out_of_range& e) {
26684       {
26685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26686       };
26687     } catch (std::exception& e) {
26688       {
26689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26690       };
26691     } catch (Dali::DaliException e) {
26692       {
26693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26694       };
26695     } catch (...) {
26696       {
26697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26698       };
26699     }
26700   }
26701
26702   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26703   return jresult;
26704 }
26705
26706
26707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26708   void * jresult ;
26709   Dali::Renderer *result = 0 ;
26710
26711   {
26712     try {
26713       result = (Dali::Renderer *)new Dali::Renderer();
26714     } catch (std::out_of_range& e) {
26715       {
26716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26717       };
26718     } catch (std::exception& e) {
26719       {
26720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26721       };
26722     } catch (Dali::DaliException e) {
26723       {
26724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26725       };
26726     } catch (...) {
26727       {
26728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26729       };
26730     }
26731   }
26732
26733   jresult = (void *)result;
26734   return jresult;
26735 }
26736
26737
26738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26739   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26740
26741   arg1 = (Dali::Renderer *)jarg1;
26742   {
26743     try {
26744       delete arg1;
26745     } catch (std::out_of_range& e) {
26746       {
26747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26748       };
26749     } catch (std::exception& e) {
26750       {
26751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26752       };
26753     } catch (Dali::DaliException e) {
26754       {
26755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26756       };
26757     } catch (...) {
26758       {
26759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26760       };
26761     }
26762   }
26763
26764 }
26765
26766
26767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26768   void * jresult ;
26769   Dali::Renderer *arg1 = 0 ;
26770   Dali::Renderer *result = 0 ;
26771
26772   arg1 = (Dali::Renderer *)jarg1;
26773   if (!arg1) {
26774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26775     return 0;
26776   }
26777   {
26778     try {
26779       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26780     } catch (std::out_of_range& e) {
26781       {
26782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26783       };
26784     } catch (std::exception& e) {
26785       {
26786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26787       };
26788     } catch (Dali::DaliException e) {
26789       {
26790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26791       };
26792     } catch (...) {
26793       {
26794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26795       };
26796     }
26797   }
26798
26799   jresult = (void *)result;
26800   return jresult;
26801 }
26802
26803
26804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26805   void * jresult ;
26806   Dali::BaseHandle arg1 ;
26807   Dali::BaseHandle *argp1 ;
26808   Dali::Renderer result;
26809
26810   argp1 = (Dali::BaseHandle *)jarg1;
26811   if (!argp1) {
26812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26813     return 0;
26814   }
26815   arg1 = *argp1;
26816   {
26817     try {
26818       result = Dali::Renderer::DownCast(arg1);
26819     } catch (std::out_of_range& e) {
26820       {
26821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26822       };
26823     } catch (std::exception& e) {
26824       {
26825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26826       };
26827     } catch (Dali::DaliException e) {
26828       {
26829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26830       };
26831     } catch (...) {
26832       {
26833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26834       };
26835     }
26836   }
26837
26838   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26839   return jresult;
26840 }
26841
26842
26843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26844   void * jresult ;
26845   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26846   Dali::Renderer *arg2 = 0 ;
26847   Dali::Renderer *result = 0 ;
26848
26849   arg1 = (Dali::Renderer *)jarg1;
26850   arg2 = (Dali::Renderer *)jarg2;
26851   if (!arg2) {
26852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26853     return 0;
26854   }
26855   {
26856     try {
26857       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26858     } catch (std::out_of_range& e) {
26859       {
26860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26861       };
26862     } catch (std::exception& e) {
26863       {
26864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26865       };
26866     } catch (Dali::DaliException e) {
26867       {
26868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26869       };
26870     } catch (...) {
26871       {
26872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26873       };
26874     }
26875   }
26876
26877   jresult = (void *)result;
26878   return jresult;
26879 }
26880
26881
26882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26883   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26884   Dali::Geometry *arg2 = 0 ;
26885
26886   arg1 = (Dali::Renderer *)jarg1;
26887   arg2 = (Dali::Geometry *)jarg2;
26888   if (!arg2) {
26889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26890     return ;
26891   }
26892   {
26893     try {
26894       (arg1)->SetGeometry(*arg2);
26895     } catch (std::out_of_range& e) {
26896       {
26897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26898       };
26899     } catch (std::exception& e) {
26900       {
26901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26902       };
26903     } catch (Dali::DaliException e) {
26904       {
26905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26906       };
26907     } catch (...) {
26908       {
26909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26910       };
26911     }
26912   }
26913
26914 }
26915
26916
26917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
26918   void * jresult ;
26919   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26920   Dali::Geometry result;
26921
26922   arg1 = (Dali::Renderer *)jarg1;
26923   {
26924     try {
26925       result = ((Dali::Renderer const *)arg1)->GetGeometry();
26926     } catch (std::out_of_range& e) {
26927       {
26928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26929       };
26930     } catch (std::exception& e) {
26931       {
26932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26933       };
26934     } catch (Dali::DaliException e) {
26935       {
26936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26937       };
26938     } catch (...) {
26939       {
26940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26941       };
26942     }
26943   }
26944
26945   jresult = new Dali::Geometry((const Dali::Geometry &)result);
26946   return jresult;
26947 }
26948
26949
26950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
26951   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26952   int arg2 ;
26953   int arg3 ;
26954
26955   arg1 = (Dali::Renderer *)jarg1;
26956   arg2 = (int)jarg2;
26957   arg3 = (int)jarg3;
26958   {
26959     try {
26960       (arg1)->SetIndexRange(arg2,arg3);
26961     } catch (std::out_of_range& e) {
26962       {
26963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26964       };
26965     } catch (std::exception& e) {
26966       {
26967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26968       };
26969     } catch (Dali::DaliException e) {
26970       {
26971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26972       };
26973     } catch (...) {
26974       {
26975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26976       };
26977     }
26978   }
26979
26980 }
26981
26982
26983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
26984   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26985   Dali::TextureSet *arg2 = 0 ;
26986
26987   arg1 = (Dali::Renderer *)jarg1;
26988   arg2 = (Dali::TextureSet *)jarg2;
26989   if (!arg2) {
26990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
26991     return ;
26992   }
26993   {
26994     try {
26995       (arg1)->SetTextures(*arg2);
26996     } catch (std::out_of_range& e) {
26997       {
26998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26999       };
27000     } catch (std::exception& e) {
27001       {
27002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27003       };
27004     } catch (Dali::DaliException e) {
27005       {
27006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27007       };
27008     } catch (...) {
27009       {
27010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27011       };
27012     }
27013   }
27014
27015 }
27016
27017
27018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27019   void * jresult ;
27020   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27021   Dali::TextureSet result;
27022
27023   arg1 = (Dali::Renderer *)jarg1;
27024   {
27025     try {
27026       result = ((Dali::Renderer const *)arg1)->GetTextures();
27027     } catch (std::out_of_range& e) {
27028       {
27029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27030       };
27031     } catch (std::exception& e) {
27032       {
27033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27034       };
27035     } catch (Dali::DaliException e) {
27036       {
27037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27038       };
27039     } catch (...) {
27040       {
27041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27042       };
27043     }
27044   }
27045
27046   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27047   return jresult;
27048 }
27049
27050
27051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27052   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27053   Dali::Shader *arg2 = 0 ;
27054
27055   arg1 = (Dali::Renderer *)jarg1;
27056   arg2 = (Dali::Shader *)jarg2;
27057   if (!arg2) {
27058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27059     return ;
27060   }
27061   {
27062     try {
27063       (arg1)->SetShader(*arg2);
27064     } catch (std::out_of_range& e) {
27065       {
27066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27067       };
27068     } catch (std::exception& e) {
27069       {
27070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27071       };
27072     } catch (Dali::DaliException e) {
27073       {
27074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27075       };
27076     } catch (...) {
27077       {
27078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27079       };
27080     }
27081   }
27082
27083 }
27084
27085
27086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27087   void * jresult ;
27088   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27089   Dali::Shader result;
27090
27091   arg1 = (Dali::Renderer *)jarg1;
27092   {
27093     try {
27094       result = ((Dali::Renderer const *)arg1)->GetShader();
27095     } catch (std::out_of_range& e) {
27096       {
27097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27098       };
27099     } catch (std::exception& e) {
27100       {
27101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27102       };
27103     } catch (Dali::DaliException e) {
27104       {
27105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27106       };
27107     } catch (...) {
27108       {
27109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27110       };
27111     }
27112   }
27113
27114   jresult = new Dali::Shader((const Dali::Shader &)result);
27115   return jresult;
27116 }
27117
27118
27119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27120   void * jresult ;
27121   Dali::FrameBuffer::Attachment *result = 0 ;
27122
27123   {
27124     try {
27125       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27126     } catch (std::out_of_range& e) {
27127       {
27128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27129       };
27130     } catch (std::exception& e) {
27131       {
27132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27133       };
27134     } catch (Dali::DaliException e) {
27135       {
27136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27137       };
27138     } catch (...) {
27139       {
27140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27141       };
27142     }
27143   }
27144
27145   jresult = (void *)result;
27146   return jresult;
27147 }
27148
27149
27150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27151   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27152
27153   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27154   {
27155     try {
27156       delete arg1;
27157     } catch (std::out_of_range& e) {
27158       {
27159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27160       };
27161     } catch (std::exception& e) {
27162       {
27163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27164       };
27165     } catch (Dali::DaliException e) {
27166       {
27167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27168       };
27169     } catch (...) {
27170       {
27171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27172       };
27173     }
27174   }
27175
27176 }
27177
27178
27179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27180   void * jresult ;
27181   unsigned int arg1 ;
27182   unsigned int arg2 ;
27183   unsigned int arg3 ;
27184   Dali::FrameBuffer result;
27185
27186   arg1 = (unsigned int)jarg1;
27187   arg2 = (unsigned int)jarg2;
27188   arg3 = (unsigned int)jarg3;
27189   {
27190     try {
27191       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27192     } catch (std::out_of_range& e) {
27193       {
27194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27195       };
27196     } catch (std::exception& e) {
27197       {
27198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27199       };
27200     } catch (Dali::DaliException e) {
27201       {
27202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27203       };
27204     } catch (...) {
27205       {
27206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27207       };
27208     }
27209   }
27210
27211   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27212   return jresult;
27213 }
27214
27215
27216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27217   void * jresult ;
27218   Dali::FrameBuffer *result = 0 ;
27219
27220   {
27221     try {
27222       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27223     } catch (std::out_of_range& e) {
27224       {
27225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27226       };
27227     } catch (std::exception& e) {
27228       {
27229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27230       };
27231     } catch (Dali::DaliException e) {
27232       {
27233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27234       };
27235     } catch (...) {
27236       {
27237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27238       };
27239     }
27240   }
27241
27242   jresult = (void *)result;
27243   return jresult;
27244 }
27245
27246
27247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27248   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27249
27250   arg1 = (Dali::FrameBuffer *)jarg1;
27251   {
27252     try {
27253       delete arg1;
27254     } catch (std::out_of_range& e) {
27255       {
27256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27257       };
27258     } catch (std::exception& e) {
27259       {
27260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27261       };
27262     } catch (Dali::DaliException e) {
27263       {
27264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27265       };
27266     } catch (...) {
27267       {
27268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27269       };
27270     }
27271   }
27272
27273 }
27274
27275
27276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27277   void * jresult ;
27278   Dali::FrameBuffer *arg1 = 0 ;
27279   Dali::FrameBuffer *result = 0 ;
27280
27281   arg1 = (Dali::FrameBuffer *)jarg1;
27282   if (!arg1) {
27283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27284     return 0;
27285   }
27286   {
27287     try {
27288       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27289     } catch (std::out_of_range& e) {
27290       {
27291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27292       };
27293     } catch (std::exception& e) {
27294       {
27295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27296       };
27297     } catch (Dali::DaliException e) {
27298       {
27299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27300       };
27301     } catch (...) {
27302       {
27303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27304       };
27305     }
27306   }
27307
27308   jresult = (void *)result;
27309   return jresult;
27310 }
27311
27312
27313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27314   void * jresult ;
27315   Dali::BaseHandle arg1 ;
27316   Dali::BaseHandle *argp1 ;
27317   Dali::FrameBuffer result;
27318
27319   argp1 = (Dali::BaseHandle *)jarg1;
27320   if (!argp1) {
27321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27322     return 0;
27323   }
27324   arg1 = *argp1;
27325   {
27326     try {
27327       result = Dali::FrameBuffer::DownCast(arg1);
27328     } catch (std::out_of_range& e) {
27329       {
27330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27331       };
27332     } catch (std::exception& e) {
27333       {
27334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27335       };
27336     } catch (Dali::DaliException e) {
27337       {
27338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27339       };
27340     } catch (...) {
27341       {
27342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27343       };
27344     }
27345   }
27346
27347   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27348   return jresult;
27349 }
27350
27351
27352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27353   void * jresult ;
27354   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27355   Dali::FrameBuffer *arg2 = 0 ;
27356   Dali::FrameBuffer *result = 0 ;
27357
27358   arg1 = (Dali::FrameBuffer *)jarg1;
27359   arg2 = (Dali::FrameBuffer *)jarg2;
27360   if (!arg2) {
27361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27362     return 0;
27363   }
27364   {
27365     try {
27366       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27367     } catch (std::out_of_range& e) {
27368       {
27369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27370       };
27371     } catch (std::exception& e) {
27372       {
27373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27374       };
27375     } catch (Dali::DaliException e) {
27376       {
27377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27378       };
27379     } catch (...) {
27380       {
27381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27382       };
27383     }
27384   }
27385
27386   jresult = (void *)result;
27387   return jresult;
27388 }
27389
27390
27391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27392   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27393   Dali::Texture *arg2 = 0 ;
27394
27395   arg1 = (Dali::FrameBuffer *)jarg1;
27396   arg2 = (Dali::Texture *)jarg2;
27397   if (!arg2) {
27398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27399     return ;
27400   }
27401   {
27402     try {
27403       (arg1)->AttachColorTexture(*arg2);
27404     } catch (std::out_of_range& e) {
27405       {
27406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27407       };
27408     } catch (std::exception& e) {
27409       {
27410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27411       };
27412     } catch (Dali::DaliException e) {
27413       {
27414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27415       };
27416     } catch (...) {
27417       {
27418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27419       };
27420     }
27421   }
27422
27423 }
27424
27425
27426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27427   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27428   Dali::Texture *arg2 = 0 ;
27429   unsigned int arg3 ;
27430   unsigned int arg4 ;
27431
27432   arg1 = (Dali::FrameBuffer *)jarg1;
27433   arg2 = (Dali::Texture *)jarg2;
27434   if (!arg2) {
27435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27436     return ;
27437   }
27438   arg3 = (unsigned int)jarg3;
27439   arg4 = (unsigned int)jarg4;
27440   {
27441     try {
27442       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27443     } catch (std::out_of_range& e) {
27444       {
27445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27446       };
27447     } catch (std::exception& e) {
27448       {
27449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27450       };
27451     } catch (Dali::DaliException e) {
27452       {
27453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27454       };
27455     } catch (...) {
27456       {
27457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27458       };
27459     }
27460   }
27461
27462 }
27463
27464
27465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27466   void * jresult ;
27467   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27468   Dali::Texture result;
27469
27470   arg1 = (Dali::FrameBuffer *)jarg1;
27471   {
27472     try {
27473       result = (arg1)->GetColorTexture();
27474     } catch (std::out_of_range& e) {
27475       {
27476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27477       };
27478     } catch (std::exception& e) {
27479       {
27480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27481       };
27482     } catch (Dali::DaliException e) {
27483       {
27484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27485       };
27486     } catch (...) {
27487       {
27488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27489       };
27490     }
27491   }
27492
27493   jresult = new Dali::Texture((const Dali::Texture &)result);
27494   return jresult;
27495 }
27496
27497
27498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27499   void * jresult ;
27500   Dali::RenderTaskList *result = 0 ;
27501
27502   {
27503     try {
27504       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27505     } catch (std::out_of_range& e) {
27506       {
27507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27508       };
27509     } catch (std::exception& e) {
27510       {
27511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27512       };
27513     } catch (Dali::DaliException e) {
27514       {
27515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27516       };
27517     } catch (...) {
27518       {
27519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27520       };
27521     }
27522   }
27523
27524   jresult = (void *)result;
27525   return jresult;
27526 }
27527
27528
27529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27530   void * jresult ;
27531   Dali::BaseHandle arg1 ;
27532   Dali::BaseHandle *argp1 ;
27533   Dali::RenderTaskList result;
27534
27535   argp1 = (Dali::BaseHandle *)jarg1;
27536   if (!argp1) {
27537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27538     return 0;
27539   }
27540   arg1 = *argp1;
27541   {
27542     try {
27543       result = Dali::RenderTaskList::DownCast(arg1);
27544     } catch (std::out_of_range& e) {
27545       {
27546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27547       };
27548     } catch (std::exception& e) {
27549       {
27550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27551       };
27552     } catch (Dali::DaliException e) {
27553       {
27554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27555       };
27556     } catch (...) {
27557       {
27558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27559       };
27560     }
27561   }
27562
27563   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27564   return jresult;
27565 }
27566
27567
27568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27569   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27570
27571   arg1 = (Dali::RenderTaskList *)jarg1;
27572   {
27573     try {
27574       delete arg1;
27575     } catch (std::out_of_range& e) {
27576       {
27577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27578       };
27579     } catch (std::exception& e) {
27580       {
27581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27582       };
27583     } catch (Dali::DaliException e) {
27584       {
27585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27586       };
27587     } catch (...) {
27588       {
27589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27590       };
27591     }
27592   }
27593
27594 }
27595
27596
27597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27598   void * jresult ;
27599   Dali::RenderTaskList *arg1 = 0 ;
27600   Dali::RenderTaskList *result = 0 ;
27601
27602   arg1 = (Dali::RenderTaskList *)jarg1;
27603   if (!arg1) {
27604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27605     return 0;
27606   }
27607   {
27608     try {
27609       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27610     } catch (std::out_of_range& e) {
27611       {
27612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27613       };
27614     } catch (std::exception& e) {
27615       {
27616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27617       };
27618     } catch (Dali::DaliException e) {
27619       {
27620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27621       };
27622     } catch (...) {
27623       {
27624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27625       };
27626     }
27627   }
27628
27629   jresult = (void *)result;
27630   return jresult;
27631 }
27632
27633
27634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27635   void * jresult ;
27636   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27637   Dali::RenderTaskList *arg2 = 0 ;
27638   Dali::RenderTaskList *result = 0 ;
27639
27640   arg1 = (Dali::RenderTaskList *)jarg1;
27641   arg2 = (Dali::RenderTaskList *)jarg2;
27642   if (!arg2) {
27643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27644     return 0;
27645   }
27646   {
27647     try {
27648       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27649     } catch (std::out_of_range& e) {
27650       {
27651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27652       };
27653     } catch (std::exception& e) {
27654       {
27655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27656       };
27657     } catch (Dali::DaliException e) {
27658       {
27659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27660       };
27661     } catch (...) {
27662       {
27663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27664       };
27665     }
27666   }
27667
27668   jresult = (void *)result;
27669   return jresult;
27670 }
27671
27672
27673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27674   void * jresult ;
27675   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27676   Dali::RenderTask result;
27677
27678   arg1 = (Dali::RenderTaskList *)jarg1;
27679   {
27680     try {
27681       result = (arg1)->CreateTask();
27682     } catch (std::out_of_range& e) {
27683       {
27684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27685       };
27686     } catch (std::exception& e) {
27687       {
27688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27689       };
27690     } catch (Dali::DaliException e) {
27691       {
27692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27693       };
27694     } catch (...) {
27695       {
27696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27697       };
27698     }
27699   }
27700
27701   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27702   return jresult;
27703 }
27704
27705
27706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27707   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27708   Dali::RenderTask arg2 ;
27709   Dali::RenderTask *argp2 ;
27710
27711   arg1 = (Dali::RenderTaskList *)jarg1;
27712   argp2 = (Dali::RenderTask *)jarg2;
27713   if (!argp2) {
27714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27715     return ;
27716   }
27717   arg2 = *argp2;
27718   {
27719     try {
27720       (arg1)->RemoveTask(arg2);
27721     } catch (std::out_of_range& e) {
27722       {
27723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27724       };
27725     } catch (std::exception& e) {
27726       {
27727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27728       };
27729     } catch (Dali::DaliException e) {
27730       {
27731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27732       };
27733     } catch (...) {
27734       {
27735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27736       };
27737     }
27738   }
27739
27740 }
27741
27742
27743 //// ===============================================end part 1 =================
27744
27745 //// ========================= part 2 ===============================
27746
27747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27748   unsigned int jresult ;
27749   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27750   unsigned int result;
27751
27752   arg1 = (Dali::RenderTaskList *)jarg1;
27753   {
27754     try {
27755       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27756     } catch (std::out_of_range& e) {
27757       {
27758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27759       };
27760     } catch (std::exception& e) {
27761       {
27762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27763       };
27764     } catch (Dali::DaliException e) {
27765       {
27766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27767       };
27768     } catch (...) {
27769       {
27770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27771       };
27772     }
27773   }
27774
27775   jresult = result;
27776   return jresult;
27777 }
27778
27779
27780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27781   void * jresult ;
27782   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27783   unsigned int arg2 ;
27784   Dali::RenderTask result;
27785
27786   arg1 = (Dali::RenderTaskList *)jarg1;
27787   arg2 = (unsigned int)jarg2;
27788   {
27789     try {
27790       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27791     } catch (std::out_of_range& e) {
27792       {
27793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27794       };
27795     } catch (std::exception& e) {
27796       {
27797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27798       };
27799     } catch (Dali::DaliException e) {
27800       {
27801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27802       };
27803     } catch (...) {
27804       {
27805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27806       };
27807     }
27808   }
27809
27810   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27811   return jresult;
27812 }
27813
27814
27815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27816   int jresult ;
27817   int result;
27818
27819   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27820   jresult = (int)result;
27821   return jresult;
27822 }
27823
27824
27825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27826   int jresult ;
27827   int result;
27828
27829   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27830   jresult = (int)result;
27831   return jresult;
27832 }
27833
27834
27835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27836   int jresult ;
27837   int result;
27838
27839   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27840   jresult = (int)result;
27841   return jresult;
27842 }
27843
27844
27845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27846   int jresult ;
27847   int result;
27848
27849   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27850   jresult = (int)result;
27851   return jresult;
27852 }
27853
27854
27855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27856   void * jresult ;
27857   Dali::RenderTask::Property *result = 0 ;
27858
27859   {
27860     try {
27861       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27862     } catch (std::out_of_range& e) {
27863       {
27864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27865       };
27866     } catch (std::exception& e) {
27867       {
27868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27869       };
27870     } catch (Dali::DaliException e) {
27871       {
27872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27873       };
27874     } catch (...) {
27875       {
27876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27877       };
27878     }
27879   }
27880
27881   jresult = (void *)result;
27882   return jresult;
27883 }
27884
27885
27886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27887   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27888
27889   arg1 = (Dali::RenderTask::Property *)jarg1;
27890   {
27891     try {
27892       delete arg1;
27893     } catch (std::out_of_range& e) {
27894       {
27895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27896       };
27897     } catch (std::exception& e) {
27898       {
27899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27900       };
27901     } catch (Dali::DaliException e) {
27902       {
27903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27904       };
27905     } catch (...) {
27906       {
27907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27908       };
27909     }
27910   }
27911
27912 }
27913
27914
27915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
27916   void * jresult ;
27917   bool (*result)(Dali::Vector2 &) = 0 ;
27918
27919   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
27920   jresult = (void *)result;
27921   return jresult;
27922 }
27923
27924
27925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
27926   void * jresult ;
27927   bool (*result)(Dali::Vector2 &) = 0 ;
27928
27929   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
27930   jresult = (void *)result;
27931   return jresult;
27932 }
27933
27934
27935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
27936   unsigned int jresult ;
27937   bool result;
27938
27939   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
27940   jresult = result;
27941   return jresult;
27942 }
27943
27944
27945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
27946   unsigned int jresult ;
27947   bool result;
27948
27949   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
27950   jresult = result;
27951   return jresult;
27952 }
27953
27954
27955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
27956   void * jresult ;
27957   Dali::Vector4 *result = 0 ;
27958
27959   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
27960   jresult = (void *)result;
27961   return jresult;
27962 }
27963
27964
27965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
27966   unsigned int jresult ;
27967   bool result;
27968
27969   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
27970   jresult = result;
27971   return jresult;
27972 }
27973
27974
27975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
27976   unsigned int jresult ;
27977   bool result;
27978
27979   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
27980   jresult = result;
27981   return jresult;
27982 }
27983
27984
27985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
27986   unsigned int jresult ;
27987   unsigned int result;
27988
27989   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
27990   jresult = result;
27991   return jresult;
27992 }
27993
27994
27995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
27996   void * jresult ;
27997   Dali::RenderTask *result = 0 ;
27998
27999   {
28000     try {
28001       result = (Dali::RenderTask *)new Dali::RenderTask();
28002     } catch (std::out_of_range& e) {
28003       {
28004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28005       };
28006     } catch (std::exception& e) {
28007       {
28008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28009       };
28010     } catch (Dali::DaliException e) {
28011       {
28012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28013       };
28014     } catch (...) {
28015       {
28016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28017       };
28018     }
28019   }
28020
28021   jresult = (void *)result;
28022   return jresult;
28023 }
28024
28025
28026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28027   void * jresult ;
28028   Dali::BaseHandle arg1 ;
28029   Dali::BaseHandle *argp1 ;
28030   Dali::RenderTask result;
28031
28032   argp1 = (Dali::BaseHandle *)jarg1;
28033   if (!argp1) {
28034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28035     return 0;
28036   }
28037   arg1 = *argp1;
28038   {
28039     try {
28040       result = Dali::RenderTask::DownCast(arg1);
28041     } catch (std::out_of_range& e) {
28042       {
28043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28044       };
28045     } catch (std::exception& e) {
28046       {
28047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28048       };
28049     } catch (Dali::DaliException e) {
28050       {
28051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28052       };
28053     } catch (...) {
28054       {
28055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28056       };
28057     }
28058   }
28059
28060   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28061   return jresult;
28062 }
28063
28064
28065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28066   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28067
28068   arg1 = (Dali::RenderTask *)jarg1;
28069   {
28070     try {
28071       delete arg1;
28072     } catch (std::out_of_range& e) {
28073       {
28074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28075       };
28076     } catch (std::exception& e) {
28077       {
28078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28079       };
28080     } catch (Dali::DaliException e) {
28081       {
28082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28083       };
28084     } catch (...) {
28085       {
28086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28087       };
28088     }
28089   }
28090
28091 }
28092
28093
28094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28095   void * jresult ;
28096   Dali::RenderTask *arg1 = 0 ;
28097   Dali::RenderTask *result = 0 ;
28098
28099   arg1 = (Dali::RenderTask *)jarg1;
28100   if (!arg1) {
28101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28102     return 0;
28103   }
28104   {
28105     try {
28106       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28107     } catch (std::out_of_range& e) {
28108       {
28109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28110       };
28111     } catch (std::exception& e) {
28112       {
28113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28114       };
28115     } catch (Dali::DaliException e) {
28116       {
28117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28118       };
28119     } catch (...) {
28120       {
28121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28122       };
28123     }
28124   }
28125
28126   jresult = (void *)result;
28127   return jresult;
28128 }
28129
28130
28131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28132   void * jresult ;
28133   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28134   Dali::RenderTask *arg2 = 0 ;
28135   Dali::RenderTask *result = 0 ;
28136
28137   arg1 = (Dali::RenderTask *)jarg1;
28138   arg2 = (Dali::RenderTask *)jarg2;
28139   if (!arg2) {
28140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28141     return 0;
28142   }
28143   {
28144     try {
28145       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28146     } catch (std::out_of_range& e) {
28147       {
28148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28149       };
28150     } catch (std::exception& e) {
28151       {
28152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28153       };
28154     } catch (Dali::DaliException e) {
28155       {
28156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28157       };
28158     } catch (...) {
28159       {
28160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28161       };
28162     }
28163   }
28164
28165   jresult = (void *)result;
28166   return jresult;
28167 }
28168
28169
28170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28171   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28172   Dali::Actor arg2 ;
28173   Dali::Actor *argp2 ;
28174
28175   arg1 = (Dali::RenderTask *)jarg1;
28176   argp2 = (Dali::Actor *)jarg2;
28177   if (!argp2) {
28178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28179     return ;
28180   }
28181   arg2 = *argp2;
28182   {
28183     try {
28184       (arg1)->SetSourceActor(arg2);
28185     } catch (std::out_of_range& e) {
28186       {
28187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28188       };
28189     } catch (std::exception& e) {
28190       {
28191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28192       };
28193     } catch (Dali::DaliException e) {
28194       {
28195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28196       };
28197     } catch (...) {
28198       {
28199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28200       };
28201     }
28202   }
28203
28204 }
28205
28206
28207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28208   void * jresult ;
28209   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28210   Dali::Actor result;
28211
28212   arg1 = (Dali::RenderTask *)jarg1;
28213   {
28214     try {
28215       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28216     } catch (std::out_of_range& e) {
28217       {
28218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28219       };
28220     } catch (std::exception& e) {
28221       {
28222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28223       };
28224     } catch (Dali::DaliException e) {
28225       {
28226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28227       };
28228     } catch (...) {
28229       {
28230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28231       };
28232     }
28233   }
28234
28235   jresult = new Dali::Actor((const Dali::Actor &)result);
28236   return jresult;
28237 }
28238
28239
28240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28241   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28242   bool arg2 ;
28243
28244   arg1 = (Dali::RenderTask *)jarg1;
28245   arg2 = jarg2 ? true : false;
28246   {
28247     try {
28248       (arg1)->SetExclusive(arg2);
28249     } catch (std::out_of_range& e) {
28250       {
28251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28252       };
28253     } catch (std::exception& e) {
28254       {
28255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28256       };
28257     } catch (Dali::DaliException e) {
28258       {
28259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28260       };
28261     } catch (...) {
28262       {
28263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28264       };
28265     }
28266   }
28267
28268 }
28269
28270
28271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28272   unsigned int jresult ;
28273   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28274   bool result;
28275
28276   arg1 = (Dali::RenderTask *)jarg1;
28277   {
28278     try {
28279       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28280     } catch (std::out_of_range& e) {
28281       {
28282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28283       };
28284     } catch (std::exception& e) {
28285       {
28286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28287       };
28288     } catch (Dali::DaliException e) {
28289       {
28290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28291       };
28292     } catch (...) {
28293       {
28294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28295       };
28296     }
28297   }
28298
28299   jresult = result;
28300   return jresult;
28301 }
28302
28303
28304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28305   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28306   bool arg2 ;
28307
28308   arg1 = (Dali::RenderTask *)jarg1;
28309   arg2 = jarg2 ? true : false;
28310   {
28311     try {
28312       (arg1)->SetInputEnabled(arg2);
28313     } catch (std::out_of_range& e) {
28314       {
28315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28316       };
28317     } catch (std::exception& e) {
28318       {
28319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28320       };
28321     } catch (Dali::DaliException e) {
28322       {
28323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28324       };
28325     } catch (...) {
28326       {
28327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28328       };
28329     }
28330   }
28331
28332 }
28333
28334
28335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28336   unsigned int jresult ;
28337   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28338   bool result;
28339
28340   arg1 = (Dali::RenderTask *)jarg1;
28341   {
28342     try {
28343       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28344     } catch (std::out_of_range& e) {
28345       {
28346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28347       };
28348     } catch (std::exception& e) {
28349       {
28350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28351       };
28352     } catch (Dali::DaliException e) {
28353       {
28354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28355       };
28356     } catch (...) {
28357       {
28358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28359       };
28360     }
28361   }
28362
28363   jresult = result;
28364   return jresult;
28365 }
28366
28367
28368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28369   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28370   Dali::CameraActor arg2 ;
28371   Dali::CameraActor *argp2 ;
28372
28373   arg1 = (Dali::RenderTask *)jarg1;
28374   argp2 = (Dali::CameraActor *)jarg2;
28375   if (!argp2) {
28376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28377     return ;
28378   }
28379   arg2 = *argp2;
28380   {
28381     try {
28382       (arg1)->SetCameraActor(arg2);
28383     } catch (std::out_of_range& e) {
28384       {
28385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28386       };
28387     } catch (std::exception& e) {
28388       {
28389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28390       };
28391     } catch (Dali::DaliException e) {
28392       {
28393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28394       };
28395     } catch (...) {
28396       {
28397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28398       };
28399     }
28400   }
28401
28402 }
28403
28404
28405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28406   void * jresult ;
28407   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28408   Dali::CameraActor result;
28409
28410   arg1 = (Dali::RenderTask *)jarg1;
28411   {
28412     try {
28413       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28414     } catch (std::out_of_range& e) {
28415       {
28416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28417       };
28418     } catch (std::exception& e) {
28419       {
28420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28421       };
28422     } catch (Dali::DaliException e) {
28423       {
28424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28425       };
28426     } catch (...) {
28427       {
28428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28429       };
28430     }
28431   }
28432
28433   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28434   return jresult;
28435 }
28436
28437
28438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28439   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28440   Dali::FrameBuffer arg2 ;
28441   Dali::FrameBuffer *argp2 ;
28442
28443   arg1 = (Dali::RenderTask *)jarg1;
28444   argp2 = (Dali::FrameBuffer *)jarg2;
28445   if (!argp2) {
28446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28447     return ;
28448   }
28449   arg2 = *argp2;
28450   {
28451     try {
28452       (arg1)->SetFrameBuffer(arg2);
28453     } catch (std::out_of_range& e) {
28454       {
28455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28456       };
28457     } catch (std::exception& e) {
28458       {
28459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28460       };
28461     } catch (Dali::DaliException e) {
28462       {
28463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28464       };
28465     } catch (...) {
28466       {
28467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28468       };
28469     }
28470   }
28471
28472 }
28473
28474
28475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28476   void * jresult ;
28477   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28478   Dali::FrameBuffer result;
28479
28480   arg1 = (Dali::RenderTask *)jarg1;
28481   {
28482     try {
28483       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28484     } catch (std::out_of_range& e) {
28485       {
28486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28487       };
28488     } catch (std::exception& e) {
28489       {
28490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28491       };
28492     } catch (Dali::DaliException e) {
28493       {
28494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28495       };
28496     } catch (...) {
28497       {
28498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28499       };
28500     }
28501   }
28502
28503   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28504   return jresult;
28505 }
28506
28507
28508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28509   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28510   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28511
28512   arg1 = (Dali::RenderTask *)jarg1;
28513   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28514   {
28515     try {
28516       (arg1)->SetScreenToFrameBufferFunction(arg2);
28517     } catch (std::out_of_range& e) {
28518       {
28519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28520       };
28521     } catch (std::exception& e) {
28522       {
28523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28524       };
28525     } catch (Dali::DaliException e) {
28526       {
28527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28528       };
28529     } catch (...) {
28530       {
28531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28532       };
28533     }
28534   }
28535
28536 }
28537
28538
28539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28540   void * jresult ;
28541   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28542   Dali::RenderTask::ScreenToFrameBufferFunction result;
28543
28544   arg1 = (Dali::RenderTask *)jarg1;
28545   {
28546     try {
28547       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28548     } catch (std::out_of_range& e) {
28549       {
28550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28551       };
28552     } catch (std::exception& e) {
28553       {
28554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28555       };
28556     } catch (Dali::DaliException e) {
28557       {
28558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28559       };
28560     } catch (...) {
28561       {
28562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28563       };
28564     }
28565   }
28566
28567   jresult = (void *)result;
28568   return jresult;
28569 }
28570
28571
28572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28573   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28574   Dali::Actor arg2 ;
28575   Dali::Actor *argp2 ;
28576
28577   arg1 = (Dali::RenderTask *)jarg1;
28578   argp2 = (Dali::Actor *)jarg2;
28579   if (!argp2) {
28580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28581     return ;
28582   }
28583   arg2 = *argp2;
28584   {
28585     try {
28586       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28587     } catch (std::out_of_range& e) {
28588       {
28589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28590       };
28591     } catch (std::exception& e) {
28592       {
28593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28594       };
28595     } catch (Dali::DaliException e) {
28596       {
28597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28598       };
28599     } catch (...) {
28600       {
28601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28602       };
28603     }
28604   }
28605
28606 }
28607
28608
28609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28610   void * jresult ;
28611   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28612   Dali::Actor result;
28613
28614   arg1 = (Dali::RenderTask *)jarg1;
28615   {
28616     try {
28617       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28618     } catch (std::out_of_range& e) {
28619       {
28620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28621       };
28622     } catch (std::exception& e) {
28623       {
28624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28625       };
28626     } catch (Dali::DaliException e) {
28627       {
28628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28629       };
28630     } catch (...) {
28631       {
28632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28633       };
28634     }
28635   }
28636
28637   jresult = new Dali::Actor((const Dali::Actor &)result);
28638   return jresult;
28639 }
28640
28641
28642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28643   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28644   Dali::Vector2 arg2 ;
28645   Dali::Vector2 *argp2 ;
28646
28647   arg1 = (Dali::RenderTask *)jarg1;
28648   argp2 = (Dali::Vector2 *)jarg2;
28649   if (!argp2) {
28650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28651     return ;
28652   }
28653   arg2 = *argp2;
28654   {
28655     try {
28656       (arg1)->SetViewportPosition(arg2);
28657     } catch (std::out_of_range& e) {
28658       {
28659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28660       };
28661     } catch (std::exception& e) {
28662       {
28663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28664       };
28665     } catch (Dali::DaliException e) {
28666       {
28667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28668       };
28669     } catch (...) {
28670       {
28671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28672       };
28673     }
28674   }
28675
28676 }
28677
28678
28679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28680   void * jresult ;
28681   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28682   Dali::Vector2 result;
28683
28684   arg1 = (Dali::RenderTask *)jarg1;
28685   {
28686     try {
28687       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28688     } catch (std::out_of_range& e) {
28689       {
28690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28691       };
28692     } catch (std::exception& e) {
28693       {
28694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28695       };
28696     } catch (Dali::DaliException e) {
28697       {
28698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28699       };
28700     } catch (...) {
28701       {
28702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28703       };
28704     }
28705   }
28706
28707   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28708   return jresult;
28709 }
28710
28711
28712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28713   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28714   Dali::Vector2 arg2 ;
28715   Dali::Vector2 *argp2 ;
28716
28717   arg1 = (Dali::RenderTask *)jarg1;
28718   argp2 = (Dali::Vector2 *)jarg2;
28719   if (!argp2) {
28720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28721     return ;
28722   }
28723   arg2 = *argp2;
28724   {
28725     try {
28726       (arg1)->SetViewportSize(arg2);
28727     } catch (std::out_of_range& e) {
28728       {
28729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28730       };
28731     } catch (std::exception& e) {
28732       {
28733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28734       };
28735     } catch (Dali::DaliException e) {
28736       {
28737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28738       };
28739     } catch (...) {
28740       {
28741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28742       };
28743     }
28744   }
28745
28746 }
28747
28748
28749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28750   void * jresult ;
28751   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28752   Dali::Vector2 result;
28753
28754   arg1 = (Dali::RenderTask *)jarg1;
28755   {
28756     try {
28757       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28758     } catch (std::out_of_range& e) {
28759       {
28760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28761       };
28762     } catch (std::exception& e) {
28763       {
28764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28765       };
28766     } catch (Dali::DaliException e) {
28767       {
28768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28769       };
28770     } catch (...) {
28771       {
28772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28773       };
28774     }
28775   }
28776
28777   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28778   return jresult;
28779 }
28780
28781
28782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28783   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28784   Dali::Viewport arg2 ;
28785   Dali::Viewport *argp2 ;
28786
28787   arg1 = (Dali::RenderTask *)jarg1;
28788   argp2 = (Dali::Viewport *)jarg2;
28789   if (!argp2) {
28790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28791     return ;
28792   }
28793   arg2 = *argp2;
28794   {
28795     try {
28796       (arg1)->SetViewport(arg2);
28797     } catch (std::out_of_range& e) {
28798       {
28799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28800       };
28801     } catch (std::exception& e) {
28802       {
28803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28804       };
28805     } catch (Dali::DaliException e) {
28806       {
28807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28808       };
28809     } catch (...) {
28810       {
28811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28812       };
28813     }
28814   }
28815
28816 }
28817
28818
28819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28820   void * jresult ;
28821   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28822   Dali::Viewport result;
28823
28824   arg1 = (Dali::RenderTask *)jarg1;
28825   {
28826     try {
28827       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28828     } catch (std::out_of_range& e) {
28829       {
28830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28831       };
28832     } catch (std::exception& e) {
28833       {
28834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28835       };
28836     } catch (Dali::DaliException e) {
28837       {
28838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28839       };
28840     } catch (...) {
28841       {
28842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28843       };
28844     }
28845   }
28846
28847   jresult = new Dali::Viewport((const Dali::Viewport &)result);
28848   return jresult;
28849 }
28850
28851
28852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
28853   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28854   Dali::Vector4 *arg2 = 0 ;
28855
28856   arg1 = (Dali::RenderTask *)jarg1;
28857   arg2 = (Dali::Vector4 *)jarg2;
28858   if (!arg2) {
28859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
28860     return ;
28861   }
28862   {
28863     try {
28864       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
28865     } catch (std::out_of_range& e) {
28866       {
28867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28868       };
28869     } catch (std::exception& e) {
28870       {
28871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28872       };
28873     } catch (Dali::DaliException e) {
28874       {
28875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28876       };
28877     } catch (...) {
28878       {
28879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28880       };
28881     }
28882   }
28883
28884 }
28885
28886
28887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
28888   void * jresult ;
28889   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28890   Dali::Vector4 result;
28891
28892   arg1 = (Dali::RenderTask *)jarg1;
28893   {
28894     try {
28895       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
28896     } catch (std::out_of_range& e) {
28897       {
28898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28899       };
28900     } catch (std::exception& e) {
28901       {
28902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28903       };
28904     } catch (Dali::DaliException e) {
28905       {
28906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28907       };
28908     } catch (...) {
28909       {
28910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28911       };
28912     }
28913   }
28914
28915   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28916   return jresult;
28917 }
28918
28919
28920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
28921   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28922   bool arg2 ;
28923
28924   arg1 = (Dali::RenderTask *)jarg1;
28925   arg2 = jarg2 ? true : false;
28926   {
28927     try {
28928       (arg1)->SetClearEnabled(arg2);
28929     } catch (std::out_of_range& e) {
28930       {
28931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28932       };
28933     } catch (std::exception& e) {
28934       {
28935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28936       };
28937     } catch (Dali::DaliException e) {
28938       {
28939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28940       };
28941     } catch (...) {
28942       {
28943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28944       };
28945     }
28946   }
28947
28948 }
28949
28950
28951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
28952   unsigned int jresult ;
28953   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28954   bool result;
28955
28956   arg1 = (Dali::RenderTask *)jarg1;
28957   {
28958     try {
28959       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
28960     } catch (std::out_of_range& e) {
28961       {
28962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28963       };
28964     } catch (std::exception& e) {
28965       {
28966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28967       };
28968     } catch (Dali::DaliException e) {
28969       {
28970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28971       };
28972     } catch (...) {
28973       {
28974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28975       };
28976     }
28977   }
28978
28979   jresult = result;
28980   return jresult;
28981 }
28982
28983
28984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
28985   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28986   bool arg2 ;
28987
28988   arg1 = (Dali::RenderTask *)jarg1;
28989   arg2 = jarg2 ? true : false;
28990   {
28991     try {
28992       (arg1)->SetCullMode(arg2);
28993     } catch (std::out_of_range& e) {
28994       {
28995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28996       };
28997     } catch (std::exception& e) {
28998       {
28999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29000       };
29001     } catch (Dali::DaliException e) {
29002       {
29003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29004       };
29005     } catch (...) {
29006       {
29007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29008       };
29009     }
29010   }
29011
29012 }
29013
29014
29015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29016   unsigned int jresult ;
29017   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29018   bool result;
29019
29020   arg1 = (Dali::RenderTask *)jarg1;
29021   {
29022     try {
29023       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29024     } catch (std::out_of_range& e) {
29025       {
29026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29027       };
29028     } catch (std::exception& e) {
29029       {
29030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29031       };
29032     } catch (Dali::DaliException e) {
29033       {
29034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29035       };
29036     } catch (...) {
29037       {
29038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29039       };
29040     }
29041   }
29042
29043   jresult = result;
29044   return jresult;
29045 }
29046
29047
29048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29049   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29050   unsigned int arg2 ;
29051
29052   arg1 = (Dali::RenderTask *)jarg1;
29053   arg2 = (unsigned int)jarg2;
29054   {
29055     try {
29056       (arg1)->SetRefreshRate(arg2);
29057     } catch (std::out_of_range& e) {
29058       {
29059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29060       };
29061     } catch (std::exception& e) {
29062       {
29063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29064       };
29065     } catch (Dali::DaliException e) {
29066       {
29067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29068       };
29069     } catch (...) {
29070       {
29071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29072       };
29073     }
29074   }
29075
29076 }
29077
29078
29079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29080   unsigned int jresult ;
29081   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29082   unsigned int result;
29083
29084   arg1 = (Dali::RenderTask *)jarg1;
29085   {
29086     try {
29087       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29088     } catch (std::out_of_range& e) {
29089       {
29090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29091       };
29092     } catch (std::exception& e) {
29093       {
29094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29095       };
29096     } catch (Dali::DaliException e) {
29097       {
29098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29099       };
29100     } catch (...) {
29101       {
29102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29103       };
29104     }
29105   }
29106
29107   jresult = result;
29108   return jresult;
29109 }
29110
29111
29112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29113   unsigned int jresult ;
29114   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29115   Dali::Vector3 *arg2 = 0 ;
29116   float *arg3 = 0 ;
29117   float *arg4 = 0 ;
29118   bool result;
29119
29120   arg1 = (Dali::RenderTask *)jarg1;
29121   arg2 = (Dali::Vector3 *)jarg2;
29122   if (!arg2) {
29123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29124     return 0;
29125   }
29126   arg3 = (float *)jarg3;
29127   arg4 = (float *)jarg4;
29128   {
29129     try {
29130       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29131     } catch (std::out_of_range& e) {
29132       {
29133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29134       };
29135     } catch (std::exception& e) {
29136       {
29137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29138       };
29139     } catch (Dali::DaliException e) {
29140       {
29141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29142       };
29143     } catch (...) {
29144       {
29145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29146       };
29147     }
29148   }
29149
29150   jresult = result;
29151   return jresult;
29152 }
29153
29154
29155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29156   unsigned int jresult ;
29157   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29158   Dali::Actor arg2 ;
29159   float arg3 ;
29160   float arg4 ;
29161   float *arg5 = 0 ;
29162   float *arg6 = 0 ;
29163   Dali::Actor *argp2 ;
29164   bool result;
29165
29166   arg1 = (Dali::RenderTask *)jarg1;
29167   argp2 = (Dali::Actor *)jarg2;
29168   if (!argp2) {
29169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29170     return 0;
29171   }
29172   arg2 = *argp2;
29173   arg3 = (float)jarg3;
29174   arg4 = (float)jarg4;
29175   arg5 = (float *)jarg5;
29176   arg6 = (float *)jarg6;
29177   {
29178     try {
29179       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29180     } catch (std::out_of_range& e) {
29181       {
29182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29183       };
29184     } catch (std::exception& e) {
29185       {
29186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29187       };
29188     } catch (Dali::DaliException e) {
29189       {
29190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29191       };
29192     } catch (...) {
29193       {
29194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29195       };
29196     }
29197   }
29198
29199   jresult = result;
29200   return jresult;
29201 }
29202
29203
29204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29205   void * jresult ;
29206   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29207   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29208
29209   arg1 = (Dali::RenderTask *)jarg1;
29210   {
29211     try {
29212       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29213     } catch (std::out_of_range& e) {
29214       {
29215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29216       };
29217     } catch (std::exception& e) {
29218       {
29219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29220       };
29221     } catch (Dali::DaliException e) {
29222       {
29223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29224       };
29225     } catch (...) {
29226       {
29227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29228       };
29229     }
29230   }
29231
29232   jresult = (void *)result;
29233   return jresult;
29234 }
29235
29236
29237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29238   void * jresult ;
29239   int arg1 ;
29240   Dali::TouchPoint::State arg2 ;
29241   float arg3 ;
29242   float arg4 ;
29243   Dali::TouchPoint *result = 0 ;
29244
29245   arg1 = (int)jarg1;
29246   arg2 = (Dali::TouchPoint::State)jarg2;
29247   arg3 = (float)jarg3;
29248   arg4 = (float)jarg4;
29249   {
29250     try {
29251       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29252     } catch (std::out_of_range& e) {
29253       {
29254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29255       };
29256     } catch (std::exception& e) {
29257       {
29258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29259       };
29260     } catch (Dali::DaliException e) {
29261       {
29262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29263       };
29264     } catch (...) {
29265       {
29266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29267       };
29268     }
29269   }
29270
29271   jresult = (void *)result;
29272   return jresult;
29273 }
29274
29275
29276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29277   void * jresult ;
29278   int arg1 ;
29279   Dali::TouchPoint::State arg2 ;
29280   float arg3 ;
29281   float arg4 ;
29282   float arg5 ;
29283   float arg6 ;
29284   Dali::TouchPoint *result = 0 ;
29285
29286   arg1 = (int)jarg1;
29287   arg2 = (Dali::TouchPoint::State)jarg2;
29288   arg3 = (float)jarg3;
29289   arg4 = (float)jarg4;
29290   arg5 = (float)jarg5;
29291   arg6 = (float)jarg6;
29292   {
29293     try {
29294       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29295     } catch (std::out_of_range& e) {
29296       {
29297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29298       };
29299     } catch (std::exception& e) {
29300       {
29301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29302       };
29303     } catch (Dali::DaliException e) {
29304       {
29305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29306       };
29307     } catch (...) {
29308       {
29309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29310       };
29311     }
29312   }
29313
29314   jresult = (void *)result;
29315   return jresult;
29316 }
29317
29318
29319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29320   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29321
29322   arg1 = (Dali::TouchPoint *)jarg1;
29323   {
29324     try {
29325       delete arg1;
29326     } catch (std::out_of_range& e) {
29327       {
29328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29329       };
29330     } catch (std::exception& e) {
29331       {
29332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29333       };
29334     } catch (Dali::DaliException e) {
29335       {
29336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29337       };
29338     } catch (...) {
29339       {
29340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29341       };
29342     }
29343   }
29344
29345 }
29346
29347
29348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29349   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29350   int arg2 ;
29351
29352   arg1 = (Dali::TouchPoint *)jarg1;
29353   arg2 = (int)jarg2;
29354   if (arg1) (arg1)->deviceId = arg2;
29355 }
29356
29357
29358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29359   int jresult ;
29360   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29361   int result;
29362
29363   arg1 = (Dali::TouchPoint *)jarg1;
29364   result = (int) ((arg1)->deviceId);
29365   jresult = result;
29366   return jresult;
29367 }
29368
29369
29370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29371   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29372   Dali::TouchPoint::State arg2 ;
29373
29374   arg1 = (Dali::TouchPoint *)jarg1;
29375   arg2 = (Dali::TouchPoint::State)jarg2;
29376   if (arg1) (arg1)->state = arg2;
29377 }
29378
29379
29380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29381   int jresult ;
29382   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29383   Dali::TouchPoint::State result;
29384
29385   arg1 = (Dali::TouchPoint *)jarg1;
29386   result = (Dali::TouchPoint::State) ((arg1)->state);
29387   jresult = (int)result;
29388   return jresult;
29389 }
29390
29391
29392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29393   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29394   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29395
29396   arg1 = (Dali::TouchPoint *)jarg1;
29397   arg2 = (Dali::Actor *)jarg2;
29398   if (arg1) (arg1)->hitActor = *arg2;
29399 }
29400
29401
29402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29403   void * jresult ;
29404   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29405   Dali::Actor *result = 0 ;
29406
29407   arg1 = (Dali::TouchPoint *)jarg1;
29408   result = (Dali::Actor *)& ((arg1)->hitActor);
29409   jresult = (void *)result;
29410   return jresult;
29411 }
29412
29413
29414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29415   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29416   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29417
29418   arg1 = (Dali::TouchPoint *)jarg1;
29419   arg2 = (Dali::Vector2 *)jarg2;
29420   if (arg1) (arg1)->local = *arg2;
29421 }
29422
29423
29424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29425   void * jresult ;
29426   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29427   Dali::Vector2 *result = 0 ;
29428
29429   arg1 = (Dali::TouchPoint *)jarg1;
29430   result = (Dali::Vector2 *)& ((arg1)->local);
29431   jresult = (void *)result;
29432   return jresult;
29433 }
29434
29435
29436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29437   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29438   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29439
29440   arg1 = (Dali::TouchPoint *)jarg1;
29441   arg2 = (Dali::Vector2 *)jarg2;
29442   if (arg1) (arg1)->screen = *arg2;
29443 }
29444
29445
29446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29447   void * jresult ;
29448   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29449   Dali::Vector2 *result = 0 ;
29450
29451   arg1 = (Dali::TouchPoint *)jarg1;
29452   result = (Dali::Vector2 *)& ((arg1)->screen);
29453   jresult = (void *)result;
29454   return jresult;
29455 }
29456
29457
29458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29459   void * jresult ;
29460   Dali::TouchData *result = 0 ;
29461
29462   {
29463     try {
29464       result = (Dali::TouchData *)new Dali::TouchData();
29465     } catch (std::out_of_range& e) {
29466       {
29467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29468       };
29469     } catch (std::exception& e) {
29470       {
29471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29472       };
29473     } catch (Dali::DaliException e) {
29474       {
29475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29476       };
29477     } catch (...) {
29478       {
29479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29480       };
29481     }
29482   }
29483
29484   jresult = (void *)result;
29485   return jresult;
29486 }
29487
29488
29489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29490   void * jresult ;
29491   Dali::TouchData *arg1 = 0 ;
29492   Dali::TouchData *result = 0 ;
29493
29494   arg1 = (Dali::TouchData *)jarg1;
29495   if (!arg1) {
29496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29497     return 0;
29498   }
29499   {
29500     try {
29501       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
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_delete_Touch(void * jarg1) {
29527   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29528
29529   arg1 = (Dali::TouchData *)jarg1;
29530   {
29531     try {
29532       delete arg1;
29533     } catch (std::out_of_range& e) {
29534       {
29535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29536       };
29537     } catch (std::exception& e) {
29538       {
29539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29540       };
29541     } catch (Dali::DaliException e) {
29542       {
29543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29544       };
29545     } catch (...) {
29546       {
29547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29548       };
29549     }
29550   }
29551
29552 }
29553
29554
29555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29556   void * jresult ;
29557   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29558   Dali::TouchData *arg2 = 0 ;
29559   Dali::TouchData *result = 0 ;
29560
29561   arg1 = (Dali::TouchData *)jarg1;
29562   arg2 = (Dali::TouchData *)jarg2;
29563   if (!arg2) {
29564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29565     return 0;
29566   }
29567   {
29568     try {
29569       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29570     } catch (std::out_of_range& e) {
29571       {
29572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29573       };
29574     } catch (std::exception& e) {
29575       {
29576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29577       };
29578     } catch (Dali::DaliException e) {
29579       {
29580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29581       };
29582     } catch (...) {
29583       {
29584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29585       };
29586     }
29587   }
29588
29589   jresult = (void *)result;
29590   return jresult;
29591 }
29592
29593
29594 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29595   unsigned long jresult ;
29596   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29597   unsigned long result;
29598
29599   arg1 = (Dali::TouchData *)jarg1;
29600   {
29601     try {
29602       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29603     } catch (std::out_of_range& e) {
29604       {
29605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29606       };
29607     } catch (std::exception& e) {
29608       {
29609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29610       };
29611     } catch (Dali::DaliException e) {
29612       {
29613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29614       };
29615     } catch (...) {
29616       {
29617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29618       };
29619     }
29620   }
29621
29622   jresult = (unsigned long)result;
29623   return jresult;
29624 }
29625
29626
29627 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29628   unsigned long jresult ;
29629   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29630   std::size_t result;
29631
29632   arg1 = (Dali::TouchData *)jarg1;
29633   {
29634     try {
29635       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29636     } catch (std::out_of_range& e) {
29637       {
29638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29639       };
29640     } catch (std::exception& e) {
29641       {
29642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29643       };
29644     } catch (Dali::DaliException e) {
29645       {
29646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29647       };
29648     } catch (...) {
29649       {
29650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29651       };
29652     }
29653   }
29654
29655   jresult = (unsigned long)result;
29656   return jresult;
29657 }
29658
29659
29660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29661   int jresult ;
29662   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29663   std::size_t arg2 ;
29664   int32_t result;
29665
29666   arg1 = (Dali::TouchData *)jarg1;
29667   arg2 = (std::size_t)jarg2;
29668   {
29669     try {
29670       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29671     } catch (std::out_of_range& e) {
29672       {
29673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29674       };
29675     } catch (std::exception& e) {
29676       {
29677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29678       };
29679     } catch (Dali::DaliException e) {
29680       {
29681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29682       };
29683     } catch (...) {
29684       {
29685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29686       };
29687     }
29688   }
29689
29690   jresult = result;
29691   return jresult;
29692 }
29693
29694
29695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29696   int jresult ;
29697   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29698   std::size_t arg2 ;
29699   Dali::PointState::Type result;
29700
29701   arg1 = (Dali::TouchData *)jarg1;
29702   arg2 = (std::size_t)jarg2;
29703   {
29704     try {
29705       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29706     } catch (std::out_of_range& e) {
29707       {
29708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29709       };
29710     } catch (std::exception& e) {
29711       {
29712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29713       };
29714     } catch (Dali::DaliException e) {
29715       {
29716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29717       };
29718     } catch (...) {
29719       {
29720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29721       };
29722     }
29723   }
29724
29725   jresult = (int)result;
29726   return jresult;
29727 }
29728
29729
29730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29731   void * jresult ;
29732   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29733   std::size_t arg2 ;
29734   Dali::Actor result;
29735
29736   arg1 = (Dali::TouchData *)jarg1;
29737   arg2 = (std::size_t)jarg2;
29738   {
29739     try {
29740       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29741     } catch (std::out_of_range& e) {
29742       {
29743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29744       };
29745     } catch (std::exception& e) {
29746       {
29747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29748       };
29749     } catch (Dali::DaliException e) {
29750       {
29751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29752       };
29753     } catch (...) {
29754       {
29755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29756       };
29757     }
29758   }
29759
29760   jresult = new Dali::Actor((const Dali::Actor &)result);
29761   return jresult;
29762 }
29763
29764
29765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29766   void * jresult ;
29767   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29768   std::size_t arg2 ;
29769   Dali::Vector2 *result = 0 ;
29770
29771   arg1 = (Dali::TouchData *)jarg1;
29772   arg2 = (std::size_t)jarg2;
29773   {
29774     try {
29775       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
29776     } catch (std::out_of_range& e) {
29777       {
29778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29779       };
29780     } catch (std::exception& e) {
29781       {
29782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29783       };
29784     } catch (Dali::DaliException e) {
29785       {
29786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29787       };
29788     } catch (...) {
29789       {
29790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29791       };
29792     }
29793   }
29794
29795   jresult = (void *)result;
29796   return jresult;
29797 }
29798
29799
29800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29801   void * jresult ;
29802   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29803   std::size_t arg2 ;
29804   Dali::Vector2 *result = 0 ;
29805
29806   arg1 = (Dali::TouchData *)jarg1;
29807   arg2 = (std::size_t)jarg2;
29808   {
29809     try {
29810       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
29811     } catch (std::out_of_range& e) {
29812       {
29813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29814       };
29815     } catch (std::exception& e) {
29816       {
29817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29818       };
29819     } catch (Dali::DaliException e) {
29820       {
29821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29822       };
29823     } catch (...) {
29824       {
29825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29826       };
29827     }
29828   }
29829
29830   jresult = (void *)result;
29831   return jresult;
29832 }
29833
29834
29835 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29836   float jresult ;
29837   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29838   std::size_t arg2 ;
29839   float result;
29840
29841   arg1 = (Dali::TouchData *)jarg1;
29842   arg2 = (std::size_t)jarg2;
29843   {
29844     try {
29845       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
29846     } catch (std::out_of_range& e) {
29847       {
29848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29849       };
29850     } catch (std::exception& e) {
29851       {
29852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29853       };
29854     } catch (Dali::DaliException e) {
29855       {
29856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29857       };
29858     } catch (...) {
29859       {
29860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29861       };
29862     }
29863   }
29864
29865   jresult = result;
29866   return jresult;
29867 }
29868
29869
29870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
29871   void * jresult ;
29872   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29873   std::size_t arg2 ;
29874   Dali::Vector2 *result = 0 ;
29875
29876   arg1 = (Dali::TouchData *)jarg1;
29877   arg2 = (std::size_t)jarg2;
29878   {
29879     try {
29880       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
29881     } catch (std::out_of_range& e) {
29882       {
29883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29884       };
29885     } catch (std::exception& e) {
29886       {
29887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29888       };
29889     } catch (Dali::DaliException e) {
29890       {
29891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29892       };
29893     } catch (...) {
29894       {
29895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29896       };
29897     }
29898   }
29899
29900   jresult = (void *)result;
29901   return jresult;
29902 }
29903
29904
29905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
29906   float jresult ;
29907   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29908   std::size_t arg2 ;
29909   float result;
29910
29911   arg1 = (Dali::TouchData *)jarg1;
29912   arg2 = (std::size_t)jarg2;
29913   {
29914     try {
29915       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
29916     } catch (std::out_of_range& e) {
29917       {
29918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29919       };
29920     } catch (std::exception& e) {
29921       {
29922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29923       };
29924     } catch (Dali::DaliException e) {
29925       {
29926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29927       };
29928     } catch (...) {
29929       {
29930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29931       };
29932     }
29933   }
29934
29935   jresult = result;
29936   return jresult;
29937 }
29938
29939
29940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
29941   void * jresult ;
29942   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29943   std::size_t arg2 ;
29944   Dali::Degree result;
29945
29946   arg1 = (Dali::TouchData *)jarg1;
29947   arg2 = (std::size_t)jarg2;
29948   {
29949     try {
29950       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
29951     } catch (std::out_of_range& e) {
29952       {
29953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29954       };
29955     } catch (std::exception& e) {
29956       {
29957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29958       };
29959     } catch (Dali::DaliException e) {
29960       {
29961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29962       };
29963     } catch (...) {
29964       {
29965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29966       };
29967     }
29968   }
29969
29970   jresult = new Dali::Degree((const Dali::Degree &)result);
29971   return jresult;
29972 }
29973
29974
29975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
29976   int jresult ;
29977   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29978   std::size_t arg2 ;
29979   Dali::MouseButton::Type result;
29980
29981   arg1 = (Dali::TouchData *)jarg1;
29982   arg2 = (std::size_t)jarg2;
29983   {
29984     try {
29985       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
29986     } catch (std::out_of_range& e) {
29987       {
29988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29989       };
29990     } catch (std::exception& e) {
29991       {
29992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29993       };
29994     } catch (Dali::DaliException e) {
29995       {
29996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29997       };
29998     } catch (...) {
29999       {
30000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30001       };
30002     }
30003   }
30004
30005   jresult = static_cast< int >(result);
30006   return jresult;
30007 }
30008
30009
30010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30011   void * jresult ;
30012   Dali::GestureDetector *result = 0 ;
30013
30014   {
30015     try {
30016       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30017     } catch (std::out_of_range& e) {
30018       {
30019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30020       };
30021     } catch (std::exception& e) {
30022       {
30023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30024       };
30025     } catch (Dali::DaliException e) {
30026       {
30027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30028       };
30029     } catch (...) {
30030       {
30031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30032       };
30033     }
30034   }
30035
30036   jresult = (void *)result;
30037   return jresult;
30038 }
30039
30040
30041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30042   void * jresult ;
30043   Dali::BaseHandle arg1 ;
30044   Dali::BaseHandle *argp1 ;
30045   Dali::GestureDetector result;
30046
30047   argp1 = (Dali::BaseHandle *)jarg1;
30048   if (!argp1) {
30049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30050     return 0;
30051   }
30052   arg1 = *argp1;
30053   {
30054     try {
30055       result = Dali::GestureDetector::DownCast(arg1);
30056     } catch (std::out_of_range& e) {
30057       {
30058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30059       };
30060     } catch (std::exception& e) {
30061       {
30062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30063       };
30064     } catch (Dali::DaliException e) {
30065       {
30066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30067       };
30068     } catch (...) {
30069       {
30070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30071       };
30072     }
30073   }
30074
30075   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30076   return jresult;
30077 }
30078
30079
30080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30081   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30082
30083   arg1 = (Dali::GestureDetector *)jarg1;
30084   {
30085     try {
30086       delete arg1;
30087     } catch (std::out_of_range& e) {
30088       {
30089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30090       };
30091     } catch (std::exception& e) {
30092       {
30093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30094       };
30095     } catch (Dali::DaliException e) {
30096       {
30097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30098       };
30099     } catch (...) {
30100       {
30101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30102       };
30103     }
30104   }
30105
30106 }
30107
30108
30109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30110   void * jresult ;
30111   Dali::GestureDetector *arg1 = 0 ;
30112   Dali::GestureDetector *result = 0 ;
30113
30114   arg1 = (Dali::GestureDetector *)jarg1;
30115   if (!arg1) {
30116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30117     return 0;
30118   }
30119   {
30120     try {
30121       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30122     } catch (std::out_of_range& e) {
30123       {
30124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30125       };
30126     } catch (std::exception& e) {
30127       {
30128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30129       };
30130     } catch (Dali::DaliException e) {
30131       {
30132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30133       };
30134     } catch (...) {
30135       {
30136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30137       };
30138     }
30139   }
30140
30141   jresult = (void *)result;
30142   return jresult;
30143 }
30144
30145
30146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30147   void * jresult ;
30148   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30149   Dali::GestureDetector *arg2 = 0 ;
30150   Dali::GestureDetector *result = 0 ;
30151
30152   arg1 = (Dali::GestureDetector *)jarg1;
30153   arg2 = (Dali::GestureDetector *)jarg2;
30154   if (!arg2) {
30155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30156     return 0;
30157   }
30158   {
30159     try {
30160       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30161     } catch (std::out_of_range& e) {
30162       {
30163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30164       };
30165     } catch (std::exception& e) {
30166       {
30167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30168       };
30169     } catch (Dali::DaliException e) {
30170       {
30171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30172       };
30173     } catch (...) {
30174       {
30175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30176       };
30177     }
30178   }
30179
30180   jresult = (void *)result;
30181   return jresult;
30182 }
30183
30184
30185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30186   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30187   Dali::Actor arg2 ;
30188   Dali::Actor *argp2 ;
30189
30190   arg1 = (Dali::GestureDetector *)jarg1;
30191   argp2 = (Dali::Actor *)jarg2;
30192   if (!argp2) {
30193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30194     return ;
30195   }
30196   arg2 = *argp2;
30197   {
30198     try {
30199       (arg1)->Attach(arg2);
30200     } catch (std::out_of_range& e) {
30201       {
30202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30203       };
30204     } catch (std::exception& e) {
30205       {
30206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30207       };
30208     } catch (Dali::DaliException e) {
30209       {
30210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30211       };
30212     } catch (...) {
30213       {
30214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30215       };
30216     }
30217   }
30218
30219 }
30220
30221
30222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30223   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30224   Dali::Actor arg2 ;
30225   Dali::Actor *argp2 ;
30226
30227   arg1 = (Dali::GestureDetector *)jarg1;
30228   argp2 = (Dali::Actor *)jarg2;
30229   if (!argp2) {
30230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30231     return ;
30232   }
30233   arg2 = *argp2;
30234   {
30235     try {
30236       (arg1)->Detach(arg2);
30237     } catch (std::out_of_range& e) {
30238       {
30239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30240       };
30241     } catch (std::exception& e) {
30242       {
30243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30244       };
30245     } catch (Dali::DaliException e) {
30246       {
30247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30248       };
30249     } catch (...) {
30250       {
30251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30252       };
30253     }
30254   }
30255
30256 }
30257
30258
30259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30260   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30261
30262   arg1 = (Dali::GestureDetector *)jarg1;
30263   {
30264     try {
30265       (arg1)->DetachAll();
30266     } catch (std::out_of_range& e) {
30267       {
30268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30269       };
30270     } catch (std::exception& e) {
30271       {
30272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30273       };
30274     } catch (Dali::DaliException e) {
30275       {
30276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30277       };
30278     } catch (...) {
30279       {
30280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30281       };
30282     }
30283   }
30284
30285 }
30286
30287
30288 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30289   unsigned long jresult ;
30290   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30291   size_t result;
30292
30293   arg1 = (Dali::GestureDetector *)jarg1;
30294   {
30295     try {
30296       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30297     } catch (std::out_of_range& e) {
30298       {
30299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30300       };
30301     } catch (std::exception& e) {
30302       {
30303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30304       };
30305     } catch (Dali::DaliException e) {
30306       {
30307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30308       };
30309     } catch (...) {
30310       {
30311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30312       };
30313     }
30314   }
30315
30316   jresult = (unsigned long)result;
30317   return jresult;
30318 }
30319
30320
30321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30322   void * jresult ;
30323   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30324   size_t arg2 ;
30325   Dali::Actor result;
30326
30327   arg1 = (Dali::GestureDetector *)jarg1;
30328   arg2 = (size_t)jarg2;
30329   {
30330     try {
30331       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30332     } catch (std::out_of_range& e) {
30333       {
30334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30335       };
30336     } catch (std::exception& e) {
30337       {
30338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30339       };
30340     } catch (Dali::DaliException e) {
30341       {
30342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30343       };
30344     } catch (...) {
30345       {
30346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30347       };
30348     }
30349   }
30350
30351   jresult = new Dali::Actor((const Dali::Actor &)result);
30352   return jresult;
30353 }
30354
30355
30356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30357   void * jresult ;
30358   Dali::Gesture *arg1 = 0 ;
30359   Dali::Gesture *result = 0 ;
30360
30361   arg1 = (Dali::Gesture *)jarg1;
30362   if (!arg1) {
30363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30364     return 0;
30365   }
30366   {
30367     try {
30368       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30369     } catch (std::out_of_range& e) {
30370       {
30371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30372       };
30373     } catch (std::exception& e) {
30374       {
30375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30376       };
30377     } catch (Dali::DaliException e) {
30378       {
30379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30380       };
30381     } catch (...) {
30382       {
30383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30384       };
30385     }
30386   }
30387
30388   jresult = (void *)result;
30389   return jresult;
30390 }
30391
30392
30393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30394   void * jresult ;
30395   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30396   Dali::Gesture *arg2 = 0 ;
30397   Dali::Gesture *result = 0 ;
30398
30399   arg1 = (Dali::Gesture *)jarg1;
30400   arg2 = (Dali::Gesture *)jarg2;
30401   if (!arg2) {
30402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30403     return 0;
30404   }
30405   {
30406     try {
30407       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30408     } catch (std::out_of_range& e) {
30409       {
30410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30411       };
30412     } catch (std::exception& e) {
30413       {
30414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30415       };
30416     } catch (Dali::DaliException e) {
30417       {
30418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30419       };
30420     } catch (...) {
30421       {
30422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30423       };
30424     }
30425   }
30426
30427   jresult = (void *)result;
30428   return jresult;
30429 }
30430
30431
30432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30433   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30434
30435   arg1 = (Dali::Gesture *)jarg1;
30436   {
30437     try {
30438       delete arg1;
30439     } catch (std::out_of_range& e) {
30440       {
30441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30442       };
30443     } catch (std::exception& e) {
30444       {
30445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30446       };
30447     } catch (Dali::DaliException e) {
30448       {
30449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30450       };
30451     } catch (...) {
30452       {
30453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30454       };
30455     }
30456   }
30457
30458 }
30459
30460
30461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30462   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30463   Dali::Gesture::Type arg2 ;
30464
30465   arg1 = (Dali::Gesture *)jarg1;
30466   arg2 = (Dali::Gesture::Type)jarg2;
30467   if (arg1) (arg1)->type = arg2;
30468 }
30469
30470
30471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30472   int jresult ;
30473   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30474   Dali::Gesture::Type result;
30475
30476   arg1 = (Dali::Gesture *)jarg1;
30477   result = (Dali::Gesture::Type) ((arg1)->type);
30478   jresult = (int)result;
30479   return jresult;
30480 }
30481
30482
30483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30484   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30485   Dali::Gesture::State arg2 ;
30486
30487   arg1 = (Dali::Gesture *)jarg1;
30488   arg2 = (Dali::Gesture::State)jarg2;
30489   if (arg1) (arg1)->state = arg2;
30490 }
30491
30492
30493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30494   int jresult ;
30495   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30496   Dali::Gesture::State result;
30497
30498   arg1 = (Dali::Gesture *)jarg1;
30499   result = (Dali::Gesture::State) ((arg1)->state);
30500   jresult = (int)result;
30501   return jresult;
30502 }
30503
30504
30505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30506   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30507   unsigned int arg2 ;
30508
30509   arg1 = (Dali::Gesture *)jarg1;
30510   arg2 = (unsigned int)jarg2;
30511   if (arg1) (arg1)->time = arg2;
30512 }
30513
30514
30515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30516   unsigned int jresult ;
30517   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30518   unsigned int result;
30519
30520   arg1 = (Dali::Gesture *)jarg1;
30521   result = (unsigned int) ((arg1)->time);
30522   jresult = result;
30523   return jresult;
30524 }
30525
30526
30527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30528   void * jresult ;
30529   Dali::HoverEvent *result = 0 ;
30530
30531   {
30532     try {
30533       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30534     } catch (std::out_of_range& e) {
30535       {
30536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30537       };
30538     } catch (std::exception& e) {
30539       {
30540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30541       };
30542     } catch (Dali::DaliException e) {
30543       {
30544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30545       };
30546     } catch (...) {
30547       {
30548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30549       };
30550     }
30551   }
30552
30553   jresult = (void *)result;
30554   return jresult;
30555 }
30556
30557
30558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30559   void * jresult ;
30560   unsigned long arg1 ;
30561   Dali::HoverEvent *result = 0 ;
30562
30563   arg1 = (unsigned long)jarg1;
30564   {
30565     try {
30566       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30567     } catch (std::out_of_range& e) {
30568       {
30569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30570       };
30571     } catch (std::exception& e) {
30572       {
30573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30574       };
30575     } catch (Dali::DaliException e) {
30576       {
30577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30578       };
30579     } catch (...) {
30580       {
30581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30582       };
30583     }
30584   }
30585
30586   jresult = (void *)result;
30587   return jresult;
30588 }
30589
30590
30591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30592   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30593
30594   arg1 = (Dali::HoverEvent *)jarg1;
30595   {
30596     try {
30597       delete arg1;
30598     } catch (std::out_of_range& e) {
30599       {
30600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30601       };
30602     } catch (std::exception& e) {
30603       {
30604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30605       };
30606     } catch (Dali::DaliException e) {
30607       {
30608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30609       };
30610     } catch (...) {
30611       {
30612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30613       };
30614     }
30615   }
30616
30617 }
30618
30619
30620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30621   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30622   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30623
30624   arg1 = (Dali::HoverEvent *)jarg1;
30625   arg2 = (Dali::TouchPointContainer *)jarg2;
30626   if (arg1) (arg1)->points = *arg2;
30627 }
30628
30629
30630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30631   void * jresult ;
30632   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30633   Dali::TouchPointContainer *result = 0 ;
30634
30635   arg1 = (Dali::HoverEvent *)jarg1;
30636   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30637   jresult = (void *)result;
30638   return jresult;
30639 }
30640
30641
30642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30643   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30644   unsigned long arg2 ;
30645
30646   arg1 = (Dali::HoverEvent *)jarg1;
30647   arg2 = (unsigned long)jarg2;
30648   if (arg1) (arg1)->time = arg2;
30649 }
30650
30651
30652 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30653   unsigned long jresult ;
30654   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30655   unsigned long result;
30656
30657   arg1 = (Dali::HoverEvent *)jarg1;
30658   result = (unsigned long) ((arg1)->time);
30659   jresult = (unsigned long)result;
30660   return jresult;
30661 }
30662
30663
30664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30665   unsigned int jresult ;
30666   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30667   unsigned int result;
30668
30669   arg1 = (Dali::HoverEvent *)jarg1;
30670   {
30671     try {
30672       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30673     } catch (std::out_of_range& e) {
30674       {
30675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30676       };
30677     } catch (std::exception& e) {
30678       {
30679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30680       };
30681     } catch (Dali::DaliException e) {
30682       {
30683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30684       };
30685     } catch (...) {
30686       {
30687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30688       };
30689     }
30690   }
30691
30692   jresult = result;
30693   return jresult;
30694 }
30695
30696
30697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30698   void * jresult ;
30699   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30700   unsigned int arg2 ;
30701   Dali::TouchPoint *result = 0 ;
30702
30703   arg1 = (Dali::HoverEvent *)jarg1;
30704   arg2 = (unsigned int)jarg2;
30705   {
30706     try {
30707       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30708     } catch (std::out_of_range& e) {
30709       {
30710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30711       };
30712     } catch (std::exception& e) {
30713       {
30714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30715       };
30716     } catch (Dali::DaliException e) {
30717       {
30718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30719       };
30720     } catch (...) {
30721       {
30722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30723       };
30724     }
30725   }
30726
30727   jresult = (void *)result;
30728   return jresult;
30729 }
30730
30731
30732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30733   void * jresult ;
30734   Dali::KeyEvent *result = 0 ;
30735
30736   {
30737     try {
30738       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30739     } catch (std::out_of_range& e) {
30740       {
30741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30742       };
30743     } catch (std::exception& e) {
30744       {
30745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30746       };
30747     } catch (Dali::DaliException e) {
30748       {
30749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30750       };
30751     } catch (...) {
30752       {
30753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30754       };
30755     }
30756   }
30757
30758   jresult = (void *)result;
30759   return jresult;
30760 }
30761
30762
30763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30764   void * jresult ;
30765   std::string *arg1 = 0 ;
30766   std::string *arg2 = 0 ;
30767   int arg3 ;
30768   int arg4 ;
30769   unsigned long arg5 ;
30770   Dali::KeyEvent::State *arg6 = 0 ;
30771   Dali::KeyEvent::State temp6 ;
30772   Dali::KeyEvent *result = 0 ;
30773
30774   if (!jarg1) {
30775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30776     return 0;
30777   }
30778   std::string arg1_str(jarg1);
30779   arg1 = &arg1_str;
30780   if (!jarg2) {
30781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30782     return 0;
30783   }
30784   std::string arg2_str(jarg2);
30785   arg2 = &arg2_str;
30786   arg3 = (int)jarg3;
30787   arg4 = (int)jarg4;
30788   arg5 = (unsigned long)jarg5;
30789   temp6 = (Dali::KeyEvent::State)jarg6;
30790   arg6 = &temp6;
30791   {
30792     try {
30793       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
30794     } catch (std::out_of_range& e) {
30795       {
30796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30797       };
30798     } catch (std::exception& e) {
30799       {
30800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30801       };
30802     } catch (Dali::DaliException e) {
30803       {
30804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30805       };
30806     } catch (...) {
30807       {
30808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30809       };
30810     }
30811   }
30812
30813   jresult = (void *)result;
30814
30815   //argout typemap for const std::string&
30816
30817
30818   //argout typemap for const std::string&
30819
30820   return jresult;
30821 }
30822
30823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30824   void * jresult ;
30825   Dali::KeyEvent *arg1 = 0 ;
30826   Dali::KeyEvent *result = 0 ;
30827
30828   arg1 = (Dali::KeyEvent *)jarg1;
30829   if (!arg1) {
30830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30831     return 0;
30832   }
30833   {
30834     try {
30835       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30836     } catch (std::out_of_range& e) {
30837       {
30838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30839       };
30840     } catch (std::exception& e) {
30841       {
30842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30843       };
30844     } catch (Dali::DaliException e) {
30845       {
30846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30847       };
30848     } catch (...) {
30849       {
30850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30851       };
30852     }
30853   }
30854
30855   jresult = (void *)result;
30856   return jresult;
30857 }
30858
30859
30860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
30861   void * jresult ;
30862   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30863   Dali::KeyEvent *arg2 = 0 ;
30864   Dali::KeyEvent *result = 0 ;
30865
30866   arg1 = (Dali::KeyEvent *)jarg1;
30867   arg2 = (Dali::KeyEvent *)jarg2;
30868   if (!arg2) {
30869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30870     return 0;
30871   }
30872   {
30873     try {
30874       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
30875     } catch (std::out_of_range& e) {
30876       {
30877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30878       };
30879     } catch (std::exception& e) {
30880       {
30881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30882       };
30883     } catch (Dali::DaliException e) {
30884       {
30885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30886       };
30887     } catch (...) {
30888       {
30889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30890       };
30891     }
30892   }
30893
30894   jresult = (void *)result;
30895   return jresult;
30896 }
30897
30898
30899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
30900   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30901
30902   arg1 = (Dali::KeyEvent *)jarg1;
30903   {
30904     try {
30905       delete arg1;
30906     } catch (std::out_of_range& e) {
30907       {
30908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30909       };
30910     } catch (std::exception& e) {
30911       {
30912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30913       };
30914     } catch (Dali::DaliException e) {
30915       {
30916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30917       };
30918     } catch (...) {
30919       {
30920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30921       };
30922     }
30923   }
30924
30925 }
30926
30927
30928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
30929   unsigned int jresult ;
30930   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30931   bool result;
30932
30933   arg1 = (Dali::KeyEvent *)jarg1;
30934   {
30935     try {
30936       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
30937     } catch (std::out_of_range& e) {
30938       {
30939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30940       };
30941     } catch (std::exception& e) {
30942       {
30943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30944       };
30945     } catch (Dali::DaliException e) {
30946       {
30947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30948       };
30949     } catch (...) {
30950       {
30951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30952       };
30953     }
30954   }
30955
30956   jresult = result;
30957   return jresult;
30958 }
30959
30960
30961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
30962   unsigned int jresult ;
30963   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30964   bool result;
30965
30966   arg1 = (Dali::KeyEvent *)jarg1;
30967   {
30968     try {
30969       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
30970     } catch (std::out_of_range& e) {
30971       {
30972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30973       };
30974     } catch (std::exception& e) {
30975       {
30976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30977       };
30978     } catch (Dali::DaliException e) {
30979       {
30980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30981       };
30982     } catch (...) {
30983       {
30984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30985       };
30986     }
30987   }
30988
30989   jresult = result;
30990   return jresult;
30991 }
30992
30993
30994 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
30995   unsigned int jresult ;
30996   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30997   bool result;
30998
30999   arg1 = (Dali::KeyEvent *)jarg1;
31000   {
31001     try {
31002       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31003     } catch (std::out_of_range& e) {
31004       {
31005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31006       };
31007     } catch (std::exception& e) {
31008       {
31009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31010       };
31011     } catch (Dali::DaliException e) {
31012       {
31013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31014       };
31015     } catch (...) {
31016       {
31017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31018       };
31019     }
31020   }
31021
31022   jresult = result;
31023   return jresult;
31024 }
31025
31026
31027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31028   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31029   std::string *arg2 = 0 ;
31030
31031   arg1 = (Dali::KeyEvent *)jarg1;
31032   if (!jarg2) {
31033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31034     return ;
31035   }
31036   std::string arg2_str(jarg2);
31037   arg2 = &arg2_str;
31038   if (arg1) (arg1)->keyPressedName = *arg2;
31039
31040   //argout typemap for const std::string&
31041
31042 }
31043
31044
31045 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31046   char * jresult ;
31047
31048   if( jarg1 == NULL )
31049   {
31050     jresult = SWIG_csharp_string_callback( "" );
31051   }
31052   else
31053   {
31054     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31055     std::string *result = 0;
31056
31057     arg1 = ( Dali::KeyEvent * )jarg1;
31058     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31059     jresult = SWIG_csharp_string_callback( result->c_str() );
31060   }
31061
31062   return jresult;
31063 }
31064
31065
31066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31067   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31068   std::string *arg2 = 0 ;
31069
31070   arg1 = (Dali::KeyEvent *)jarg1;
31071   if (!jarg2) {
31072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31073     return ;
31074   }
31075   std::string arg2_str(jarg2);
31076   arg2 = &arg2_str;
31077   if (arg1) (arg1)->keyPressed = *arg2;
31078
31079   //argout typemap for const std::string&
31080
31081 }
31082
31083
31084 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31085   char * jresult ;
31086   if( NULL == jarg1 )
31087   {
31088     jresult = SWIG_csharp_string_callback( "" );
31089   }
31090   else
31091   {
31092     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31093     std::string *result = 0;
31094
31095     arg1 = ( Dali::KeyEvent * )jarg1;
31096     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31097     jresult = SWIG_csharp_string_callback( result->c_str() );
31098   }
31099   return jresult;
31100 }
31101
31102
31103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31104   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31105   int arg2 ;
31106
31107   arg1 = (Dali::KeyEvent *)jarg1;
31108   arg2 = (int)jarg2;
31109   if (arg1) (arg1)->keyCode = arg2;
31110 }
31111
31112
31113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31114   int jresult ;
31115   if( NULL == jarg1 )
31116   {
31117     jresult = -1;
31118   }
31119   else
31120   {
31121     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31122     int result;
31123
31124     arg1 = ( Dali::KeyEvent * )jarg1;
31125     result = (int)( ( arg1 )->keyCode );
31126     jresult = result;
31127   }
31128   return jresult;
31129 }
31130
31131
31132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31133   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31134   int arg2 ;
31135
31136   arg1 = (Dali::KeyEvent *)jarg1;
31137   arg2 = (int)jarg2;
31138   if (arg1) (arg1)->keyModifier = arg2;
31139 }
31140
31141
31142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31143   int jresult ;
31144   if( jarg1 == NULL )
31145   {
31146     jresult = -1;
31147   }
31148   else
31149   {
31150     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31151     int result;
31152
31153     arg1 = ( Dali::KeyEvent * )jarg1;
31154     result = (int)( ( arg1 )->keyModifier );
31155     jresult = result;
31156   }
31157   return jresult;
31158 }
31159
31160
31161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31162   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31163   unsigned long arg2 ;
31164
31165   arg1 = (Dali::KeyEvent *)jarg1;
31166   arg2 = (unsigned long)jarg2;
31167   if (arg1) (arg1)->time = arg2;
31168 }
31169
31170
31171 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31172   unsigned long jresult ;
31173   if( jarg1 == NULL )
31174   {
31175     jresult = 0;
31176   }
31177   else
31178   {
31179     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31180     unsigned long result;
31181
31182     arg1 = ( Dali::KeyEvent * )jarg1;
31183     result = (unsigned long)( ( arg1 )->time );
31184     jresult = (unsigned long)result;
31185   }
31186   return jresult;
31187 }
31188
31189
31190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31191   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31192   Dali::KeyEvent::State arg2 ;
31193
31194   arg1 = (Dali::KeyEvent *)jarg1;
31195   arg2 = (Dali::KeyEvent::State)jarg2;
31196   if (arg1) (arg1)->state = arg2;
31197 }
31198
31199
31200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31201   int jresult ;
31202   if( jarg1 == NULL )
31203   {
31204     jresult = -1;
31205   }
31206   else
31207   {
31208     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31209     Dali::KeyEvent::State result;
31210
31211     arg1 = ( Dali::KeyEvent * )jarg1;
31212     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31213     jresult = (int)result;
31214   }
31215   return jresult;
31216 }
31217
31218 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31219   char * jresult ;
31220   std::string result;
31221   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31222
31223   arg1 = (Dali::KeyEvent *)jarg1;
31224   if (!arg1) {
31225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31226     return 0;
31227   }
31228   {
31229     try {
31230       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31231     } catch (std::out_of_range& e) {
31232       {
31233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31234       };
31235     } catch (std::exception& e) {
31236       {
31237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31238       };
31239     } catch (Dali::DaliException e) {
31240       {
31241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31242       };
31243     } catch (...) {
31244       {
31245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31246       };
31247     }
31248
31249   }
31250
31251   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31252   return jresult;
31253 }
31254
31255
31256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31257   void * jresult ;
31258   Dali::LongPressGestureDetector *result = 0 ;
31259
31260   {
31261     try {
31262       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31263     } catch (std::out_of_range& e) {
31264       {
31265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31266       };
31267     } catch (std::exception& e) {
31268       {
31269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31270       };
31271     } catch (Dali::DaliException e) {
31272       {
31273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31274       };
31275     } catch (...) {
31276       {
31277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31278       };
31279     }
31280   }
31281
31282   jresult = (void *)result;
31283   return jresult;
31284 }
31285
31286
31287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31288   void * jresult ;
31289   Dali::LongPressGestureDetector result;
31290
31291   {
31292     try {
31293       result = Dali::LongPressGestureDetector::New();
31294     } catch (std::out_of_range& e) {
31295       {
31296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31297       };
31298     } catch (std::exception& e) {
31299       {
31300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31301       };
31302     } catch (Dali::DaliException e) {
31303       {
31304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31305       };
31306     } catch (...) {
31307       {
31308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31309       };
31310     }
31311   }
31312
31313   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31314   return jresult;
31315 }
31316
31317
31318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31319   void * jresult ;
31320   unsigned int arg1 ;
31321   Dali::LongPressGestureDetector result;
31322
31323   arg1 = (unsigned int)jarg1;
31324   {
31325     try {
31326       result = Dali::LongPressGestureDetector::New(arg1);
31327     } catch (std::out_of_range& e) {
31328       {
31329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31330       };
31331     } catch (std::exception& e) {
31332       {
31333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31334       };
31335     } catch (Dali::DaliException e) {
31336       {
31337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31338       };
31339     } catch (...) {
31340       {
31341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31342       };
31343     }
31344   }
31345
31346   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31347   return jresult;
31348 }
31349
31350
31351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31352   void * jresult ;
31353   unsigned int arg1 ;
31354   unsigned int arg2 ;
31355   Dali::LongPressGestureDetector result;
31356
31357   arg1 = (unsigned int)jarg1;
31358   arg2 = (unsigned int)jarg2;
31359   {
31360     try {
31361       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31362     } catch (std::out_of_range& e) {
31363       {
31364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31365       };
31366     } catch (std::exception& e) {
31367       {
31368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31369       };
31370     } catch (Dali::DaliException e) {
31371       {
31372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31373       };
31374     } catch (...) {
31375       {
31376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31377       };
31378     }
31379   }
31380
31381   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31382   return jresult;
31383 }
31384
31385
31386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31387   void * jresult ;
31388   Dali::BaseHandle arg1 ;
31389   Dali::BaseHandle *argp1 ;
31390   Dali::LongPressGestureDetector result;
31391
31392   argp1 = (Dali::BaseHandle *)jarg1;
31393   if (!argp1) {
31394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31395     return 0;
31396   }
31397   arg1 = *argp1;
31398   {
31399     try {
31400       result = Dali::LongPressGestureDetector::DownCast(arg1);
31401     } catch (std::out_of_range& e) {
31402       {
31403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31404       };
31405     } catch (std::exception& e) {
31406       {
31407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31408       };
31409     } catch (Dali::DaliException e) {
31410       {
31411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31412       };
31413     } catch (...) {
31414       {
31415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31416       };
31417     }
31418   }
31419
31420   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31421   return jresult;
31422 }
31423
31424
31425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31426   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31427
31428   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31429   {
31430     try {
31431       delete arg1;
31432     } catch (std::out_of_range& e) {
31433       {
31434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31435       };
31436     } catch (std::exception& e) {
31437       {
31438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31439       };
31440     } catch (Dali::DaliException e) {
31441       {
31442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31443       };
31444     } catch (...) {
31445       {
31446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31447       };
31448     }
31449   }
31450
31451 }
31452
31453
31454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31455   void * jresult ;
31456   Dali::LongPressGestureDetector *arg1 = 0 ;
31457   Dali::LongPressGestureDetector *result = 0 ;
31458
31459   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31460   if (!arg1) {
31461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31462     return 0;
31463   }
31464   {
31465     try {
31466       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31467     } catch (std::out_of_range& e) {
31468       {
31469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31470       };
31471     } catch (std::exception& e) {
31472       {
31473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31474       };
31475     } catch (Dali::DaliException e) {
31476       {
31477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31478       };
31479     } catch (...) {
31480       {
31481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31482       };
31483     }
31484   }
31485
31486   jresult = (void *)result;
31487   return jresult;
31488 }
31489
31490
31491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31492   void * jresult ;
31493   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31494   Dali::LongPressGestureDetector *arg2 = 0 ;
31495   Dali::LongPressGestureDetector *result = 0 ;
31496
31497   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31498   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31499   if (!arg2) {
31500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31501     return 0;
31502   }
31503   {
31504     try {
31505       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31506     } catch (std::out_of_range& e) {
31507       {
31508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31509       };
31510     } catch (std::exception& e) {
31511       {
31512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31513       };
31514     } catch (Dali::DaliException e) {
31515       {
31516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31517       };
31518     } catch (...) {
31519       {
31520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31521       };
31522     }
31523   }
31524
31525   jresult = (void *)result;
31526   return jresult;
31527 }
31528
31529
31530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31531   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31532   unsigned int arg2 ;
31533
31534   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31535   arg2 = (unsigned int)jarg2;
31536   {
31537     try {
31538       (arg1)->SetTouchesRequired(arg2);
31539     } catch (std::out_of_range& e) {
31540       {
31541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31542       };
31543     } catch (std::exception& e) {
31544       {
31545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31546       };
31547     } catch (Dali::DaliException e) {
31548       {
31549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31550       };
31551     } catch (...) {
31552       {
31553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31554       };
31555     }
31556   }
31557
31558 }
31559
31560
31561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31562   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31563   unsigned int arg2 ;
31564   unsigned int arg3 ;
31565
31566   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31567   arg2 = (unsigned int)jarg2;
31568   arg3 = (unsigned int)jarg3;
31569   {
31570     try {
31571       (arg1)->SetTouchesRequired(arg2,arg3);
31572     } catch (std::out_of_range& e) {
31573       {
31574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31575       };
31576     } catch (std::exception& e) {
31577       {
31578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31579       };
31580     } catch (Dali::DaliException e) {
31581       {
31582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31583       };
31584     } catch (...) {
31585       {
31586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31587       };
31588     }
31589   }
31590
31591 }
31592
31593
31594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31595   unsigned int jresult ;
31596   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31597   unsigned int result;
31598
31599   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31600   {
31601     try {
31602       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31603     } catch (std::out_of_range& e) {
31604       {
31605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31606       };
31607     } catch (std::exception& e) {
31608       {
31609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31610       };
31611     } catch (Dali::DaliException e) {
31612       {
31613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31614       };
31615     } catch (...) {
31616       {
31617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31618       };
31619     }
31620   }
31621
31622   jresult = result;
31623   return jresult;
31624 }
31625
31626
31627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31628   unsigned int jresult ;
31629   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31630   unsigned int result;
31631
31632   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31633   {
31634     try {
31635       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31636     } catch (std::out_of_range& e) {
31637       {
31638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31639       };
31640     } catch (std::exception& e) {
31641       {
31642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31643       };
31644     } catch (Dali::DaliException e) {
31645       {
31646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31647       };
31648     } catch (...) {
31649       {
31650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31651       };
31652     }
31653   }
31654
31655   jresult = result;
31656   return jresult;
31657 }
31658
31659
31660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31661   void * jresult ;
31662   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31663   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31664
31665   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31666   {
31667     try {
31668       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31669     } catch (std::out_of_range& e) {
31670       {
31671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31672       };
31673     } catch (std::exception& e) {
31674       {
31675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31676       };
31677     } catch (Dali::DaliException e) {
31678       {
31679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31680       };
31681     } catch (...) {
31682       {
31683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31684       };
31685     }
31686   }
31687
31688   jresult = (void *)result;
31689   return jresult;
31690 }
31691
31692
31693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31694   void * jresult ;
31695   Dali::Gesture::State arg1 ;
31696   Dali::LongPressGesture *result = 0 ;
31697
31698   arg1 = (Dali::Gesture::State)jarg1;
31699   {
31700     try {
31701       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31702     } catch (std::out_of_range& e) {
31703       {
31704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31705       };
31706     } catch (std::exception& e) {
31707       {
31708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31709       };
31710     } catch (Dali::DaliException e) {
31711       {
31712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31713       };
31714     } catch (...) {
31715       {
31716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31717       };
31718     }
31719   }
31720
31721   jresult = (void *)result;
31722   return jresult;
31723 }
31724
31725
31726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31727   void * jresult ;
31728   Dali::LongPressGesture *arg1 = 0 ;
31729   Dali::LongPressGesture *result = 0 ;
31730
31731   arg1 = (Dali::LongPressGesture *)jarg1;
31732   if (!arg1) {
31733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31734     return 0;
31735   }
31736   {
31737     try {
31738       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31739     } catch (std::out_of_range& e) {
31740       {
31741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31742       };
31743     } catch (std::exception& e) {
31744       {
31745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31746       };
31747     } catch (Dali::DaliException e) {
31748       {
31749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31750       };
31751     } catch (...) {
31752       {
31753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31754       };
31755     }
31756   }
31757
31758   jresult = (void *)result;
31759   return jresult;
31760 }
31761
31762
31763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31764   void * jresult ;
31765   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31766   Dali::LongPressGesture *arg2 = 0 ;
31767   Dali::LongPressGesture *result = 0 ;
31768
31769   arg1 = (Dali::LongPressGesture *)jarg1;
31770   arg2 = (Dali::LongPressGesture *)jarg2;
31771   if (!arg2) {
31772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31773     return 0;
31774   }
31775   {
31776     try {
31777       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31778     } catch (std::out_of_range& e) {
31779       {
31780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31781       };
31782     } catch (std::exception& e) {
31783       {
31784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31785       };
31786     } catch (Dali::DaliException e) {
31787       {
31788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31789       };
31790     } catch (...) {
31791       {
31792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31793       };
31794     }
31795   }
31796
31797   jresult = (void *)result;
31798   return jresult;
31799 }
31800
31801
31802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31803   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31804
31805   arg1 = (Dali::LongPressGesture *)jarg1;
31806   {
31807     try {
31808       delete arg1;
31809     } catch (std::out_of_range& e) {
31810       {
31811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31812       };
31813     } catch (std::exception& e) {
31814       {
31815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31816       };
31817     } catch (Dali::DaliException e) {
31818       {
31819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31820       };
31821     } catch (...) {
31822       {
31823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31824       };
31825     }
31826   }
31827
31828 }
31829
31830
31831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
31832   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31833   unsigned int arg2 ;
31834
31835   arg1 = (Dali::LongPressGesture *)jarg1;
31836   arg2 = (unsigned int)jarg2;
31837   if (arg1) (arg1)->numberOfTouches = arg2;
31838 }
31839
31840
31841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
31842   unsigned int jresult ;
31843   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31844   unsigned int result;
31845
31846   arg1 = (Dali::LongPressGesture *)jarg1;
31847   result = (unsigned int) ((arg1)->numberOfTouches);
31848   jresult = result;
31849   return jresult;
31850 }
31851
31852
31853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
31854   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31855   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31856
31857   arg1 = (Dali::LongPressGesture *)jarg1;
31858   arg2 = (Dali::Vector2 *)jarg2;
31859   if (arg1) (arg1)->screenPoint = *arg2;
31860 }
31861
31862
31863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
31864   void * jresult ;
31865   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31866   Dali::Vector2 *result = 0 ;
31867
31868   arg1 = (Dali::LongPressGesture *)jarg1;
31869   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
31870   jresult = (void *)result;
31871   return jresult;
31872 }
31873
31874
31875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
31876   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31877   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31878
31879   arg1 = (Dali::LongPressGesture *)jarg1;
31880   arg2 = (Dali::Vector2 *)jarg2;
31881   if (arg1) (arg1)->localPoint = *arg2;
31882 }
31883
31884
31885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
31886   void * jresult ;
31887   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31888   Dali::Vector2 *result = 0 ;
31889
31890   arg1 = (Dali::LongPressGesture *)jarg1;
31891   result = (Dali::Vector2 *)& ((arg1)->localPoint);
31892   jresult = (void *)result;
31893   return jresult;
31894 }
31895
31896
31897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
31898   void * jresult ;
31899   Dali::WheelEvent *result = 0 ;
31900
31901   {
31902     try {
31903       result = (Dali::WheelEvent *)new Dali::WheelEvent();
31904     } catch (std::out_of_range& e) {
31905       {
31906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31907       };
31908     } catch (std::exception& e) {
31909       {
31910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31911       };
31912     } catch (Dali::DaliException e) {
31913       {
31914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31915       };
31916     } catch (...) {
31917       {
31918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31919       };
31920     }
31921   }
31922
31923   jresult = (void *)result;
31924   return jresult;
31925 }
31926
31927
31928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
31929   void * jresult ;
31930   Dali::WheelEvent::Type arg1 ;
31931   int arg2 ;
31932   unsigned int arg3 ;
31933   Dali::Vector2 arg4 ;
31934   int arg5 ;
31935   unsigned int arg6 ;
31936   Dali::Vector2 *argp4 ;
31937   Dali::WheelEvent *result = 0 ;
31938
31939   arg1 = (Dali::WheelEvent::Type)jarg1;
31940   arg2 = (int)jarg2;
31941   arg3 = (unsigned int)jarg3;
31942   argp4 = (Dali::Vector2 *)jarg4;
31943   if (!argp4) {
31944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
31945     return 0;
31946   }
31947   arg4 = *argp4;
31948   arg5 = (int)jarg5;
31949   arg6 = (unsigned int)jarg6;
31950   {
31951     try {
31952       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
31953     } catch (std::out_of_range& e) {
31954       {
31955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31956       };
31957     } catch (std::exception& e) {
31958       {
31959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31960       };
31961     } catch (Dali::DaliException e) {
31962       {
31963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31964       };
31965     } catch (...) {
31966       {
31967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31968       };
31969     }
31970   }
31971
31972   jresult = (void *)result;
31973   return jresult;
31974 }
31975
31976
31977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
31978   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
31979
31980   arg1 = (Dali::WheelEvent *)jarg1;
31981   {
31982     try {
31983       delete arg1;
31984     } catch (std::out_of_range& e) {
31985       {
31986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31987       };
31988     } catch (std::exception& e) {
31989       {
31990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31991       };
31992     } catch (Dali::DaliException e) {
31993       {
31994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31995       };
31996     } catch (...) {
31997       {
31998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31999       };
32000     }
32001   }
32002
32003 }
32004
32005
32006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32007   unsigned int jresult ;
32008   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32009   bool result;
32010
32011   arg1 = (Dali::WheelEvent *)jarg1;
32012   {
32013     try {
32014       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32015     } catch (std::out_of_range& e) {
32016       {
32017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32018       };
32019     } catch (std::exception& e) {
32020       {
32021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32022       };
32023     } catch (Dali::DaliException e) {
32024       {
32025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32026       };
32027     } catch (...) {
32028       {
32029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32030       };
32031     }
32032   }
32033
32034   jresult = result;
32035   return jresult;
32036 }
32037
32038
32039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32040   unsigned int jresult ;
32041   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32042   bool result;
32043
32044   arg1 = (Dali::WheelEvent *)jarg1;
32045   {
32046     try {
32047       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32048     } catch (std::out_of_range& e) {
32049       {
32050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32051       };
32052     } catch (std::exception& e) {
32053       {
32054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32055       };
32056     } catch (Dali::DaliException e) {
32057       {
32058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32059       };
32060     } catch (...) {
32061       {
32062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32063       };
32064     }
32065   }
32066
32067   jresult = result;
32068   return jresult;
32069 }
32070
32071
32072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32073   unsigned int jresult ;
32074   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32075   bool result;
32076
32077   arg1 = (Dali::WheelEvent *)jarg1;
32078   {
32079     try {
32080       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32081     } catch (std::out_of_range& e) {
32082       {
32083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32084       };
32085     } catch (std::exception& e) {
32086       {
32087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32088       };
32089     } catch (Dali::DaliException e) {
32090       {
32091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32092       };
32093     } catch (...) {
32094       {
32095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32096       };
32097     }
32098   }
32099
32100   jresult = result;
32101   return jresult;
32102 }
32103
32104
32105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32106   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32107   Dali::WheelEvent::Type arg2 ;
32108
32109   arg1 = (Dali::WheelEvent *)jarg1;
32110   arg2 = (Dali::WheelEvent::Type)jarg2;
32111   if (arg1) (arg1)->type = arg2;
32112 }
32113
32114
32115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32116   int jresult ;
32117   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32118   Dali::WheelEvent::Type result;
32119
32120   arg1 = (Dali::WheelEvent *)jarg1;
32121   result = (Dali::WheelEvent::Type) ((arg1)->type);
32122   jresult = (int)result;
32123   return jresult;
32124 }
32125
32126
32127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32128   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32129   int arg2 ;
32130
32131   arg1 = (Dali::WheelEvent *)jarg1;
32132   arg2 = (int)jarg2;
32133   if (arg1) (arg1)->direction = arg2;
32134 }
32135
32136
32137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32138   int jresult ;
32139   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32140   int result;
32141
32142   arg1 = (Dali::WheelEvent *)jarg1;
32143   result = (int) ((arg1)->direction);
32144   jresult = result;
32145   return jresult;
32146 }
32147
32148
32149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32150   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32151   unsigned int arg2 ;
32152
32153   arg1 = (Dali::WheelEvent *)jarg1;
32154   arg2 = (unsigned int)jarg2;
32155   if (arg1) (arg1)->modifiers = arg2;
32156 }
32157
32158
32159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32160   unsigned int jresult ;
32161   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32162   unsigned int result;
32163
32164   arg1 = (Dali::WheelEvent *)jarg1;
32165   result = (unsigned int) ((arg1)->modifiers);
32166   jresult = result;
32167   return jresult;
32168 }
32169
32170
32171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32172   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32173   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32174
32175   arg1 = (Dali::WheelEvent *)jarg1;
32176   arg2 = (Dali::Vector2 *)jarg2;
32177   if (arg1) (arg1)->point = *arg2;
32178 }
32179
32180
32181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32182   void * jresult ;
32183   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32184   Dali::Vector2 *result = 0 ;
32185
32186   arg1 = (Dali::WheelEvent *)jarg1;
32187   result = (Dali::Vector2 *)& ((arg1)->point);
32188   jresult = (void *)result;
32189   return jresult;
32190 }
32191
32192
32193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32194   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32195   int arg2 ;
32196
32197   arg1 = (Dali::WheelEvent *)jarg1;
32198   arg2 = (int)jarg2;
32199   if (arg1) (arg1)->z = arg2;
32200 }
32201
32202
32203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32204   int jresult ;
32205   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32206   int result;
32207
32208   arg1 = (Dali::WheelEvent *)jarg1;
32209   result = (int) ((arg1)->z);
32210   jresult = result;
32211   return jresult;
32212 }
32213
32214
32215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32216   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32217   unsigned int arg2 ;
32218
32219   arg1 = (Dali::WheelEvent *)jarg1;
32220   arg2 = (unsigned int)jarg2;
32221   if (arg1) (arg1)->timeStamp = arg2;
32222 }
32223
32224
32225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32226   unsigned int jresult ;
32227   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32228   unsigned int result;
32229
32230   arg1 = (Dali::WheelEvent *)jarg1;
32231   result = (unsigned int) ((arg1)->timeStamp);
32232   jresult = result;
32233   return jresult;
32234 }
32235
32236 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32237   char * jresult ;
32238   Dali::KeyEvent *arg1 = 0 ;
32239   std::string result;
32240
32241   arg1 = (Dali::KeyEvent *)jarg1;
32242   if (!arg1) {
32243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32244     return 0;
32245   }
32246   {
32247     try {
32248       result = arg1->GetDeviceName();
32249     } catch (std::out_of_range& e) {
32250       {
32251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32252       };
32253     } catch (std::exception& e) {
32254       {
32255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32256       };
32257     } catch (Dali::DaliException e) {
32258       {
32259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32260       };
32261     } catch (...) {
32262       {
32263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32264       };
32265     }
32266   }
32267
32268   jresult = SWIG_csharp_string_callback((&result)->c_str());
32269   return jresult;
32270 }
32271
32272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32273   int jresult ;
32274   Dali::KeyEvent *arg1 = 0 ;
32275   Dali::Device::Class::Type result;
32276
32277   arg1 = (Dali::KeyEvent *)jarg1;
32278   if (!arg1) {
32279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32280     return 0;
32281   }
32282   {
32283     try {
32284       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32285     } catch (std::out_of_range& e) {
32286       {
32287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32288       };
32289     } catch (std::exception& e) {
32290       {
32291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32292       };
32293     } catch (Dali::DaliException e) {
32294       {
32295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32296       };
32297     } catch (...) {
32298       {
32299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32300       };
32301     }
32302   }
32303
32304   jresult = (int)result;
32305   return jresult;
32306 }
32307
32308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32309   int jresult ;
32310   Dali::KeyEvent *arg1 = 0 ;
32311   Dali::Device::Subclass::Type result;
32312
32313   arg1 = (Dali::KeyEvent *)jarg1;
32314   if (!arg1) {
32315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32316     return 0;
32317   }
32318   {
32319     try {
32320       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32321     } catch (std::out_of_range& e) {
32322       {
32323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32324       };
32325     } catch (std::exception& e) {
32326       {
32327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32328       };
32329     } catch (Dali::DaliException e) {
32330       {
32331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32332       };
32333     } catch (...) {
32334       {
32335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32336       };
32337     }
32338   }
32339
32340   jresult = (int)result;
32341   return jresult;
32342 }
32343
32344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32345   Dali::Actor arg1 ;
32346   Dali::Actor *argp1 ;
32347
32348   argp1 = (Dali::Actor *)jarg1;
32349   if (!argp1) {
32350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32351     return ;
32352   }
32353   arg1 = *argp1;
32354   {
32355     try {
32356       arg1.Raise();
32357     } catch (std::out_of_range& e) {
32358       {
32359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32360       };
32361     } catch (std::exception& e) {
32362       {
32363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32364       };
32365     } catch (Dali::DaliException e) {
32366       {
32367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32368       };
32369     } catch (...) {
32370       {
32371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32372       };
32373     }
32374   }
32375
32376 }
32377
32378
32379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32380   Dali::Actor arg1 ;
32381   Dali::Actor *argp1 ;
32382
32383   argp1 = (Dali::Actor *)jarg1;
32384   if (!argp1) {
32385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32386     return ;
32387   }
32388   arg1 = *argp1;
32389   {
32390     try {
32391       arg1.Lower();
32392     } catch (std::out_of_range& e) {
32393       {
32394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32395       };
32396     } catch (std::exception& e) {
32397       {
32398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32399       };
32400     } catch (Dali::DaliException e) {
32401       {
32402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32403       };
32404     } catch (...) {
32405       {
32406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32407       };
32408     }
32409   }
32410
32411 }
32412
32413
32414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32415   Dali::Actor arg1 ;
32416   Dali::Actor *argp1 ;
32417
32418   argp1 = (Dali::Actor *)jarg1;
32419   if (!argp1) {
32420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32421     return ;
32422   }
32423   arg1 = *argp1;
32424   {
32425     try {
32426       arg1.RaiseToTop();
32427     } catch (std::out_of_range& e) {
32428       {
32429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32430       };
32431     } catch (std::exception& e) {
32432       {
32433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32434       };
32435     } catch (Dali::DaliException e) {
32436       {
32437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32438       };
32439     } catch (...) {
32440       {
32441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32442       };
32443     }
32444   }
32445
32446 }
32447
32448
32449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32450   Dali::Actor arg1 ;
32451   Dali::Actor *argp1 ;
32452
32453   argp1 = (Dali::Actor *)jarg1;
32454   if (!argp1) {
32455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32456     return ;
32457   }
32458   arg1 = *argp1;
32459   {
32460     try {
32461       arg1.LowerToBottom();
32462     } catch (std::out_of_range& e) {
32463       {
32464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32465       };
32466     } catch (std::exception& e) {
32467       {
32468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32469       };
32470     } catch (Dali::DaliException e) {
32471       {
32472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32473       };
32474     } catch (...) {
32475       {
32476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32477       };
32478     }
32479   }
32480
32481 }
32482
32483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32484   Dali::Actor arg1 ;
32485   Dali::Actor arg2 ;
32486   Dali::Actor *argp1 ;
32487   Dali::Actor *argp2 ;
32488
32489   argp1 = (Dali::Actor *)jarg1;
32490   if (!argp1) {
32491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32492     return ;
32493   }
32494   arg1 = *argp1;
32495   argp2 = (Dali::Actor *)jarg2;
32496   if (!argp2) {
32497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32498     return ;
32499   }
32500   arg2 = *argp2;
32501   {
32502     try {
32503       arg1.RaiseAbove(arg2);
32504     } catch (std::out_of_range& e) {
32505       {
32506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32507       };
32508     } catch (std::exception& e) {
32509       {
32510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32511       };
32512     } catch (Dali::DaliException e) {
32513       {
32514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32515       };
32516     } catch (...) {
32517       {
32518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32519       };
32520     }
32521   }
32522
32523 }
32524
32525
32526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32527   Dali::Actor arg1 ;
32528   Dali::Actor arg2 ;
32529   Dali::Actor *argp1 ;
32530   Dali::Actor *argp2 ;
32531
32532   argp1 = (Dali::Actor *)jarg1;
32533   if (!argp1) {
32534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32535     return ;
32536   }
32537   arg1 = *argp1;
32538   argp2 = (Dali::Actor *)jarg2;
32539   if (!argp2) {
32540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32541     return ;
32542   }
32543   arg2 = *argp2;
32544   {
32545     try {
32546       arg1.LowerBelow(arg2);
32547     } catch (std::out_of_range& e) {
32548       {
32549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32550       };
32551     } catch (std::exception& e) {
32552       {
32553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32554       };
32555     } catch (Dali::DaliException e) {
32556       {
32557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32558       };
32559     } catch (...) {
32560       {
32561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32562       };
32563     }
32564   }
32565
32566 }
32567
32568
32569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32570   void * jresult ;
32571   Dali::Actor arg1 ;
32572   Dali::Actor *argp1 ;
32573   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32574
32575   argp1 = (Dali::Actor *)jarg1;
32576   if (!argp1) {
32577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32578     return 0;
32579   }
32580   arg1 = *argp1;
32581   {
32582     try {
32583       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32584     } catch (std::out_of_range& e) {
32585       {
32586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32587       };
32588     } catch (std::exception& e) {
32589       {
32590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32591       };
32592     } catch (Dali::DaliException e) {
32593       {
32594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32595       };
32596     } catch (...) {
32597       {
32598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32599       };
32600     }
32601   }
32602
32603   jresult = (void *)result;
32604   return jresult;
32605 }
32606
32607
32608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32609   void * jresult ;
32610   Dali::Actor *arg1 ;
32611   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32612
32613   arg1 = (Dali::Actor *)jarg1;
32614   {
32615     try {
32616       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32617     } catch (std::out_of_range& e) {
32618       {
32619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32620       };
32621     } catch (std::exception& e) {
32622       {
32623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32624       };
32625     } catch (Dali::DaliException e) {
32626       {
32627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32628       };
32629     } catch (...) {
32630       {
32631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32632       };
32633     }
32634   }
32635
32636   jresult = (void *)result;
32637   return jresult;
32638 }
32639
32640
32641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32642   int jresult ;
32643   int result;
32644
32645   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32646   jresult = (int)result;
32647   return jresult;
32648 }
32649
32650
32651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32652   int jresult ;
32653   int result;
32654
32655   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32656   jresult = (int)result;
32657   return jresult;
32658 }
32659
32660
32661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32662   int jresult ;
32663   int result;
32664
32665   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32666   jresult = (int)result;
32667   return jresult;
32668 }
32669
32670
32671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32672   int jresult ;
32673   int result;
32674
32675   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32676   jresult = (int)result;
32677   return jresult;
32678 }
32679
32680
32681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32682   int jresult ;
32683   int result;
32684
32685   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32686   jresult = (int)result;
32687   return jresult;
32688 }
32689
32690
32691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32692   int jresult ;
32693   int result;
32694
32695   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32696   jresult = (int)result;
32697   return jresult;
32698 }
32699
32700
32701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32702   int jresult ;
32703   int result;
32704
32705   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32706   jresult = (int)result;
32707   return jresult;
32708 }
32709
32710
32711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32712   int jresult ;
32713   int result;
32714
32715   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32716   jresult = (int)result;
32717   return jresult;
32718 }
32719
32720
32721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32722   int jresult ;
32723   int result;
32724
32725   result = (int)Dali::Actor::Property::SIZE;
32726   jresult = (int)result;
32727   return jresult;
32728 }
32729
32730
32731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32732   int jresult ;
32733   int result;
32734
32735   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32736   jresult = (int)result;
32737   return jresult;
32738 }
32739
32740
32741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32742   int jresult ;
32743   int result;
32744
32745   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32746   jresult = (int)result;
32747   return jresult;
32748 }
32749
32750
32751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32752   int jresult ;
32753   int result;
32754
32755   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32756   jresult = (int)result;
32757   return jresult;
32758 }
32759
32760
32761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32762   int jresult ;
32763   int result;
32764
32765   result = (int)Dali::Actor::Property::POSITION;
32766   jresult = (int)result;
32767   return jresult;
32768 }
32769
32770
32771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32772   int jresult ;
32773   int result;
32774
32775   result = (int)Dali::Actor::Property::POSITION_X;
32776   jresult = (int)result;
32777   return jresult;
32778 }
32779
32780
32781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32782   int jresult ;
32783   int result;
32784
32785   result = (int)Dali::Actor::Property::POSITION_Y;
32786   jresult = (int)result;
32787   return jresult;
32788 }
32789
32790
32791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32792   int jresult ;
32793   int result;
32794
32795   result = (int)Dali::Actor::Property::POSITION_Z;
32796   jresult = (int)result;
32797   return jresult;
32798 }
32799
32800
32801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32802   int jresult ;
32803   int result;
32804
32805   result = (int)Dali::Actor::Property::WORLD_POSITION;
32806   jresult = (int)result;
32807   return jresult;
32808 }
32809
32810
32811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
32812   int jresult ;
32813   int result;
32814
32815   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
32816   jresult = (int)result;
32817   return jresult;
32818 }
32819
32820
32821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
32822   int jresult ;
32823   int result;
32824
32825   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
32826   jresult = (int)result;
32827   return jresult;
32828 }
32829
32830
32831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
32832   int jresult ;
32833   int result;
32834
32835   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
32836   jresult = (int)result;
32837   return jresult;
32838 }
32839
32840
32841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
32842   int jresult ;
32843   int result;
32844
32845   result = (int)Dali::Actor::Property::ORIENTATION;
32846   jresult = (int)result;
32847   return jresult;
32848 }
32849
32850
32851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
32852   int jresult ;
32853   int result;
32854
32855   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
32856   jresult = (int)result;
32857   return jresult;
32858 }
32859
32860
32861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
32862   int jresult ;
32863   int result;
32864
32865   result = (int)Dali::Actor::Property::SCALE;
32866   jresult = (int)result;
32867   return jresult;
32868 }
32869
32870
32871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
32872   int jresult ;
32873   int result;
32874
32875   result = (int)Dali::Actor::Property::SCALE_X;
32876   jresult = (int)result;
32877   return jresult;
32878 }
32879
32880
32881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
32882   int jresult ;
32883   int result;
32884
32885   result = (int)Dali::Actor::Property::SCALE_Y;
32886   jresult = (int)result;
32887   return jresult;
32888 }
32889
32890
32891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
32892   int jresult ;
32893   int result;
32894
32895   result = (int)Dali::Actor::Property::SCALE_Z;
32896   jresult = (int)result;
32897   return jresult;
32898 }
32899
32900
32901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
32902   int jresult ;
32903   int result;
32904
32905   result = (int)Dali::Actor::Property::WORLD_SCALE;
32906   jresult = (int)result;
32907   return jresult;
32908 }
32909
32910
32911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
32912   int jresult ;
32913   int result;
32914
32915   result = (int)Dali::Actor::Property::VISIBLE;
32916   jresult = (int)result;
32917   return jresult;
32918 }
32919
32920
32921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
32922   int jresult ;
32923   int result;
32924
32925   result = (int)Dali::Actor::Property::COLOR;
32926   jresult = (int)result;
32927   return jresult;
32928 }
32929
32930
32931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
32932   int jresult ;
32933   int result;
32934
32935   result = (int)Dali::Actor::Property::COLOR_RED;
32936   jresult = (int)result;
32937   return jresult;
32938 }
32939
32940
32941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
32942   int jresult ;
32943   int result;
32944
32945   result = (int)Dali::Actor::Property::COLOR_GREEN;
32946   jresult = (int)result;
32947   return jresult;
32948 }
32949
32950
32951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
32952   int jresult ;
32953   int result;
32954
32955   result = (int)Dali::Actor::Property::COLOR_BLUE;
32956   jresult = (int)result;
32957   return jresult;
32958 }
32959
32960
32961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
32962   int jresult ;
32963   int result;
32964
32965   result = (int)Dali::Actor::Property::COLOR_ALPHA;
32966   jresult = (int)result;
32967   return jresult;
32968 }
32969
32970
32971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
32972   int jresult ;
32973   int result;
32974
32975   result = (int)Dali::Actor::Property::WORLD_COLOR;
32976   jresult = (int)result;
32977   return jresult;
32978 }
32979
32980
32981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
32982   int jresult ;
32983   int result;
32984
32985   result = (int)Dali::Actor::Property::WORLD_MATRIX;
32986   jresult = (int)result;
32987   return jresult;
32988 }
32989
32990
32991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
32992   int jresult ;
32993   int result;
32994
32995   result = (int)Dali::Actor::Property::NAME;
32996   jresult = (int)result;
32997   return jresult;
32998 }
32999
33000
33001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33002   int jresult ;
33003   int result;
33004
33005   result = (int)Dali::Actor::Property::SENSITIVE;
33006   jresult = (int)result;
33007   return jresult;
33008 }
33009
33010
33011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33012   int jresult ;
33013   int result;
33014
33015   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33016   jresult = (int)result;
33017   return jresult;
33018 }
33019
33020
33021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33022   int jresult ;
33023   int result;
33024
33025   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33026   jresult = (int)result;
33027   return jresult;
33028 }
33029
33030
33031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33032   int jresult ;
33033   int result;
33034
33035   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33036   jresult = (int)result;
33037   return jresult;
33038 }
33039
33040
33041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33042   int jresult ;
33043   int result;
33044
33045   result = (int)Dali::Actor::Property::COLOR_MODE;
33046   jresult = (int)result;
33047   return jresult;
33048 }
33049
33050
33051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33052   int jresult ;
33053   int result;
33054
33055   result = (int)Dali::Actor::Property::DRAW_MODE;
33056   jresult = (int)result;
33057   return jresult;
33058 }
33059
33060
33061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33062   int jresult ;
33063   int result;
33064
33065   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33066   jresult = (int)result;
33067   return jresult;
33068 }
33069
33070
33071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33072   int jresult ;
33073   int result;
33074
33075   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33076   jresult = (int)result;
33077   return jresult;
33078 }
33079
33080
33081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33082   int jresult ;
33083   int result;
33084
33085   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33086   jresult = (int)result;
33087   return jresult;
33088 }
33089
33090
33091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33092   int jresult ;
33093   int result;
33094
33095   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33096   jresult = (int)result;
33097   return jresult;
33098 }
33099
33100
33101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33102   int jresult ;
33103   int result;
33104
33105   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33106   jresult = (int)result;
33107   return jresult;
33108 }
33109
33110
33111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33112   int jresult ;
33113   int result;
33114
33115   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33116   jresult = (int)result;
33117   return jresult;
33118 }
33119
33120
33121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33122   int jresult ;
33123   int result;
33124
33125   result = (int)Dali::Actor::Property::PADDING;
33126   jresult = (int)result;
33127   return jresult;
33128 }
33129
33130
33131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33132   int jresult ;
33133   int result;
33134
33135   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33136   jresult = (int)result;
33137   return jresult;
33138 }
33139
33140
33141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33142   int jresult ;
33143   int result;
33144
33145   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33146   jresult = (int)result;
33147   return jresult;
33148 }
33149
33150
33151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33152   int jresult ;
33153   int result;
33154
33155   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33156   jresult = (int)result;
33157   return jresult;
33158 }
33159
33160
33161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33162   int jresult ;
33163   int result;
33164
33165   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33166   jresult = (int)result;
33167   return jresult;
33168 }
33169
33170 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
33171
33172   return Dali::Actor::Property::OPACITY;
33173 }
33174
33175 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
33176
33177   return Dali::Actor::Property::SCREEN_POSITION;
33178 }
33179
33180 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
33181
33182   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
33183 }
33184
33185 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
33186   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
33187 }
33188
33189 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
33190   return Dali::Actor::Property::LAYOUT_DIRECTION;
33191 }
33192
33193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33194   void * jresult ;
33195   Dali::Actor::Property *result = 0 ;
33196
33197   {
33198     try {
33199       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33200     } catch (std::out_of_range& e) {
33201       {
33202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33203       };
33204     } catch (std::exception& e) {
33205       {
33206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33207       };
33208     } catch (Dali::DaliException e) {
33209       {
33210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33211       };
33212     } catch (...) {
33213       {
33214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33215       };
33216     }
33217   }
33218
33219   jresult = (void *)result;
33220   return jresult;
33221 }
33222
33223
33224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33225   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33226
33227   arg1 = (Dali::Actor::Property *)jarg1;
33228   {
33229     try {
33230       delete arg1;
33231     } catch (std::out_of_range& e) {
33232       {
33233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33234       };
33235     } catch (std::exception& e) {
33236       {
33237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33238       };
33239     } catch (Dali::DaliException e) {
33240       {
33241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33242       };
33243     } catch (...) {
33244       {
33245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33246       };
33247     }
33248   }
33249
33250 }
33251
33252
33253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33254   void * jresult ;
33255   Dali::Actor *result = 0 ;
33256
33257   {
33258     try {
33259       result = (Dali::Actor *)new Dali::Actor();
33260     } catch (std::out_of_range& e) {
33261       {
33262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33263       };
33264     } catch (std::exception& e) {
33265       {
33266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33267       };
33268     } catch (Dali::DaliException e) {
33269       {
33270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33271       };
33272     } catch (...) {
33273       {
33274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33275       };
33276     }
33277   }
33278
33279   jresult = (void *)result;
33280   return jresult;
33281 }
33282
33283
33284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33285   void * jresult ;
33286   Dali::Actor result;
33287
33288   {
33289     try {
33290       result = Dali::Actor::New();
33291     } catch (std::out_of_range& e) {
33292       {
33293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33294       };
33295     } catch (std::exception& e) {
33296       {
33297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33298       };
33299     } catch (Dali::DaliException e) {
33300       {
33301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33302       };
33303     } catch (...) {
33304       {
33305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33306       };
33307     }
33308   }
33309
33310   jresult = new Dali::Actor((const Dali::Actor &)result);
33311   return jresult;
33312 }
33313
33314
33315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33316   void * jresult ;
33317   Dali::BaseHandle arg1 ;
33318   Dali::BaseHandle *argp1 ;
33319   Dali::Actor result;
33320
33321   argp1 = (Dali::BaseHandle *)jarg1;
33322   if (!argp1) {
33323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33324     return 0;
33325   }
33326   arg1 = *argp1;
33327   {
33328     try {
33329       result = Dali::Actor::DownCast(arg1);
33330     } catch (std::out_of_range& e) {
33331       {
33332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33333       };
33334     } catch (std::exception& e) {
33335       {
33336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33337       };
33338     } catch (Dali::DaliException e) {
33339       {
33340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33341       };
33342     } catch (...) {
33343       {
33344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33345       };
33346     }
33347   }
33348
33349   jresult = new Dali::Actor((const Dali::Actor &)result);
33350   return jresult;
33351 }
33352
33353
33354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33355   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33356
33357   arg1 = (Dali::Actor *)jarg1;
33358   {
33359     try {
33360       delete arg1;
33361     } catch (std::out_of_range& e) {
33362       {
33363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33364       };
33365     } catch (std::exception& e) {
33366       {
33367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33368       };
33369     } catch (Dali::DaliException e) {
33370       {
33371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33372       };
33373     } catch (...) {
33374       {
33375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33376       };
33377     }
33378   }
33379
33380 }
33381
33382
33383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33384   void * jresult ;
33385   Dali::Actor *arg1 = 0 ;
33386   Dali::Actor *result = 0 ;
33387
33388   arg1 = (Dali::Actor *)jarg1;
33389   if (!arg1) {
33390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33391     return 0;
33392   }
33393   {
33394     try {
33395       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33396     } catch (std::out_of_range& e) {
33397       {
33398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33399       };
33400     } catch (std::exception& e) {
33401       {
33402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33403       };
33404     } catch (Dali::DaliException e) {
33405       {
33406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33407       };
33408     } catch (...) {
33409       {
33410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33411       };
33412     }
33413   }
33414
33415   jresult = (void *)result;
33416   return jresult;
33417 }
33418
33419
33420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33421   void * jresult ;
33422   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33423   Dali::Actor *arg2 = 0 ;
33424   Dali::Actor *result = 0 ;
33425
33426   arg1 = (Dali::Actor *)jarg1;
33427   arg2 = (Dali::Actor *)jarg2;
33428   if (!arg2) {
33429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33430     return 0;
33431   }
33432   {
33433     try {
33434       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33435     } catch (std::out_of_range& e) {
33436       {
33437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33438       };
33439     } catch (std::exception& e) {
33440       {
33441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33442       };
33443     } catch (Dali::DaliException e) {
33444       {
33445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33446       };
33447     } catch (...) {
33448       {
33449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33450       };
33451     }
33452   }
33453
33454   jresult = (void *)result;
33455   return jresult;
33456 }
33457
33458
33459 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33460   char * jresult ;
33461   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33462   std::string *result = 0 ;
33463
33464   arg1 = (Dali::Actor *)jarg1;
33465   {
33466     try {
33467       std::string name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33468       result = (std::string *) &name;
33469     } catch (std::out_of_range& e) {
33470       {
33471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33472       };
33473     } catch (std::exception& e) {
33474       {
33475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33476       };
33477     } catch (Dali::DaliException e) {
33478       {
33479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33480       };
33481     } catch (...) {
33482       {
33483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33484       };
33485     }
33486   }
33487
33488   jresult = SWIG_csharp_string_callback(result->c_str());
33489   return jresult;
33490 }
33491
33492
33493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33494   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33495   std::string *arg2 = 0 ;
33496
33497   arg1 = (Dali::Actor *)jarg1;
33498   if (!jarg2) {
33499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33500     return ;
33501   }
33502   std::string arg2_str(jarg2);
33503   arg2 = &arg2_str;
33504   {
33505     try {
33506       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33507     } catch (std::out_of_range& e) {
33508       {
33509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33510       };
33511     } catch (std::exception& e) {
33512       {
33513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33514       };
33515     } catch (Dali::DaliException e) {
33516       {
33517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33518       };
33519     } catch (...) {
33520       {
33521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33522       };
33523     }
33524   }
33525
33526
33527   //argout typemap for const std::string&
33528
33529 }
33530
33531
33532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33533   unsigned int jresult ;
33534   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33535   unsigned int result;
33536
33537   arg1 = (Dali::Actor *)jarg1;
33538
33539   if(!arg1) {
33540     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33541     return -1;
33542   }
33543
33544   {
33545     try {
33546       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
33547     } catch (std::out_of_range& e) {
33548       {
33549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33550       };
33551     } catch (std::exception& e) {
33552       {
33553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33554       };
33555     } catch (Dali::DaliException e) {
33556       {
33557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33558       };
33559     } catch (...) {
33560       {
33561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33562       };
33563     }
33564   }
33565
33566   jresult = result;
33567   return jresult;
33568 }
33569
33570
33571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33572   unsigned int jresult ;
33573   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33574   bool result;
33575
33576   arg1 = (Dali::Actor *)jarg1;
33577   {
33578     try {
33579       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
33580     } catch (std::out_of_range& e) {
33581       {
33582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33583       };
33584     } catch (std::exception& e) {
33585       {
33586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33587       };
33588     } catch (Dali::DaliException e) {
33589       {
33590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33591       };
33592     } catch (...) {
33593       {
33594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33595       };
33596     }
33597   }
33598
33599   jresult = result;
33600   return jresult;
33601 }
33602
33603
33604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33605   unsigned int jresult ;
33606   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33607   bool result;
33608
33609   arg1 = (Dali::Actor *)jarg1;
33610   {
33611     try {
33612       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
33613     } catch (std::out_of_range& e) {
33614       {
33615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33616       };
33617     } catch (std::exception& e) {
33618       {
33619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33620       };
33621     } catch (Dali::DaliException e) {
33622       {
33623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33624       };
33625     } catch (...) {
33626       {
33627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33628       };
33629     }
33630   }
33631
33632   jresult = result;
33633   return jresult;
33634 }
33635
33636
33637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33638   unsigned int jresult ;
33639   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33640   bool result;
33641
33642   arg1 = (Dali::Actor *)jarg1;
33643   {
33644     try {
33645       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
33646     } catch (std::out_of_range& e) {
33647       {
33648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33649       };
33650     } catch (std::exception& e) {
33651       {
33652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33653       };
33654     } catch (Dali::DaliException e) {
33655       {
33656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33657       };
33658     } catch (...) {
33659       {
33660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33661       };
33662     }
33663   }
33664
33665   jresult = result;
33666   return jresult;
33667 }
33668
33669
33670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33671   void * jresult ;
33672   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33673   Dali::Layer result;
33674
33675   arg1 = (Dali::Actor *)jarg1;
33676   {
33677     try {
33678       result = (arg1)->GetLayer();
33679     } catch (std::out_of_range& e) {
33680       {
33681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33682       };
33683     } catch (std::exception& e) {
33684       {
33685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33686       };
33687     } catch (Dali::DaliException e) {
33688       {
33689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33690       };
33691     } catch (...) {
33692       {
33693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33694       };
33695     }
33696   }
33697
33698   jresult = new Dali::Layer((const Dali::Layer &)result);
33699   return jresult;
33700 }
33701
33702
33703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33704   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33705   Dali::Actor arg2 ;
33706   Dali::Actor *argp2 ;
33707
33708   arg1 = (Dali::Actor *)jarg1;
33709   argp2 = (Dali::Actor *)jarg2;
33710   if (!argp2) {
33711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33712     return ;
33713   }
33714   arg2 = *argp2;
33715   {
33716     try {
33717       (arg1)->Add(arg2);
33718     } catch (std::out_of_range& e) {
33719       {
33720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33721       };
33722     } catch (std::exception& e) {
33723       {
33724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33725       };
33726     } catch (Dali::DaliException e) {
33727       {
33728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33729       };
33730     } catch (...) {
33731       {
33732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33733       };
33734     }
33735   }
33736
33737 }
33738
33739
33740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33741   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33742   Dali::Actor arg2 ;
33743   Dali::Actor *argp2 ;
33744
33745   arg1 = (Dali::Actor *)jarg1;
33746   argp2 = (Dali::Actor *)jarg2;
33747   if (!argp2) {
33748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33749     return ;
33750   }
33751   arg2 = *argp2;
33752   {
33753     try {
33754       (arg1)->Remove(arg2);
33755     } catch (std::out_of_range& e) {
33756       {
33757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33758       };
33759     } catch (std::exception& e) {
33760       {
33761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33762       };
33763     } catch (Dali::DaliException e) {
33764       {
33765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33766       };
33767     } catch (...) {
33768       {
33769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33770       };
33771     }
33772   }
33773
33774 }
33775
33776
33777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33778   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33779
33780   arg1 = (Dali::Actor *)jarg1;
33781   {
33782     try {
33783       (arg1)->Unparent();
33784     } catch (std::out_of_range& e) {
33785       {
33786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33787       };
33788     } catch (std::exception& e) {
33789       {
33790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33791       };
33792     } catch (Dali::DaliException e) {
33793       {
33794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33795       };
33796     } catch (...) {
33797       {
33798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33799       };
33800     }
33801   }
33802
33803 }
33804
33805
33806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33807   unsigned int jresult ;
33808   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33809   unsigned int result;
33810
33811   arg1 = (Dali::Actor *)jarg1;
33812   {
33813     try {
33814       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33815     } catch (std::out_of_range& e) {
33816       {
33817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33818       };
33819     } catch (std::exception& e) {
33820       {
33821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33822       };
33823     } catch (Dali::DaliException e) {
33824       {
33825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33826       };
33827     } catch (...) {
33828       {
33829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33830       };
33831     }
33832   }
33833
33834   jresult = result;
33835   return jresult;
33836 }
33837
33838
33839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
33840   void * jresult ;
33841   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33842   unsigned int arg2 ;
33843   Dali::Actor result;
33844
33845   arg1 = (Dali::Actor *)jarg1;
33846   arg2 = (unsigned int)jarg2;
33847   {
33848     try {
33849       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
33850     } catch (std::out_of_range& e) {
33851       {
33852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33853       };
33854     } catch (std::exception& e) {
33855       {
33856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33857       };
33858     } catch (Dali::DaliException e) {
33859       {
33860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33861       };
33862     } catch (...) {
33863       {
33864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33865       };
33866     }
33867   }
33868
33869   jresult = new Dali::Actor((const Dali::Actor &)result);
33870   return jresult;
33871 }
33872
33873
33874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
33875   void * jresult ;
33876   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33877   std::string *arg2 = 0 ;
33878   Dali::Actor result;
33879
33880   arg1 = (Dali::Actor *)jarg1;
33881   if (!jarg2) {
33882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33883     return 0;
33884   }
33885   std::string arg2_str(jarg2);
33886   arg2 = &arg2_str;
33887   {
33888     try {
33889       result = (arg1)->FindChildByName((std::string const &)*arg2);
33890     } catch (std::out_of_range& e) {
33891       {
33892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33893       };
33894     } catch (std::exception& e) {
33895       {
33896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33897       };
33898     } catch (Dali::DaliException e) {
33899       {
33900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33901       };
33902     } catch (...) {
33903       {
33904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33905       };
33906     }
33907   }
33908
33909   jresult = new Dali::Actor((const Dali::Actor &)result);
33910
33911   //argout typemap for const std::string&
33912
33913   return jresult;
33914 }
33915
33916
33917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
33918   void * jresult ;
33919   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33920   unsigned int arg2 ;
33921   Dali::Actor result;
33922
33923   arg1 = (Dali::Actor *)jarg1;
33924   arg2 = (unsigned int)jarg2;
33925   {
33926     try {
33927       result = (arg1)->FindChildById(arg2);
33928     } catch (std::out_of_range& e) {
33929       {
33930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33931       };
33932     } catch (std::exception& e) {
33933       {
33934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33935       };
33936     } catch (Dali::DaliException e) {
33937       {
33938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33939       };
33940     } catch (...) {
33941       {
33942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33943       };
33944     }
33945   }
33946
33947   jresult = new Dali::Actor((const Dali::Actor &)result);
33948   return jresult;
33949 }
33950
33951
33952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
33953   void * jresult ;
33954   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33955   Dali::Actor result;
33956
33957   arg1 = (Dali::Actor *)jarg1;
33958   {
33959     try {
33960       result = ((Dali::Actor const *)arg1)->GetParent();
33961     } catch (std::out_of_range& e) {
33962       {
33963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33964       };
33965     } catch (std::exception& e) {
33966       {
33967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33968       };
33969     } catch (Dali::DaliException e) {
33970       {
33971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33972       };
33973     } catch (...) {
33974       {
33975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33976       };
33977     }
33978   }
33979
33980   jresult = new Dali::Actor((const Dali::Actor &)result);
33981   return jresult;
33982 }
33983
33984
33985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
33986   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33987   Dali::Vector3 *arg2 = 0 ;
33988
33989   arg1 = (Dali::Actor *)jarg1;
33990   arg2 = (Dali::Vector3 *)jarg2;
33991   if (!arg2) {
33992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33993     return ;
33994   }
33995   {
33996     try {
33997       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
33998     } catch (std::out_of_range& e) {
33999       {
34000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34001       };
34002     } catch (std::exception& e) {
34003       {
34004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34005       };
34006     } catch (Dali::DaliException e) {
34007       {
34008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34009       };
34010     } catch (...) {
34011       {
34012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34013       };
34014     }
34015   }
34016
34017 }
34018
34019
34020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34021   void * jresult ;
34022   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34023   Dali::Vector3 result;
34024
34025   arg1 = (Dali::Actor *)jarg1;
34026   {
34027     try {
34028       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34029     } catch (std::out_of_range& e) {
34030       {
34031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34032       };
34033     } catch (std::exception& e) {
34034       {
34035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34036       };
34037     } catch (Dali::DaliException e) {
34038       {
34039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34040       };
34041     } catch (...) {
34042       {
34043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34044       };
34045     }
34046   }
34047
34048   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34049   return jresult;
34050 }
34051
34052
34053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34054   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34055   Dali::Vector3 *arg2 = 0 ;
34056
34057   arg1 = (Dali::Actor *)jarg1;
34058   arg2 = (Dali::Vector3 *)jarg2;
34059   if (!arg2) {
34060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34061     return ;
34062   }
34063   {
34064     try {
34065       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34066     } catch (std::out_of_range& e) {
34067       {
34068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34069       };
34070     } catch (std::exception& e) {
34071       {
34072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34073       };
34074     } catch (Dali::DaliException e) {
34075       {
34076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34077       };
34078     } catch (...) {
34079       {
34080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34081       };
34082     }
34083   }
34084
34085 }
34086
34087
34088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34089   void * jresult ;
34090   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34091   Dali::Vector3 result;
34092
34093   arg1 = (Dali::Actor *)jarg1;
34094   {
34095     try {
34096       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34097     } catch (std::out_of_range& e) {
34098       {
34099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34100       };
34101     } catch (std::exception& e) {
34102       {
34103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34104       };
34105     } catch (Dali::DaliException e) {
34106       {
34107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34108       };
34109     } catch (...) {
34110       {
34111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34112       };
34113     }
34114   }
34115
34116   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34117   return jresult;
34118 }
34119
34120
34121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34122   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34123   float arg2 ;
34124   float arg3 ;
34125
34126   arg1 = (Dali::Actor *)jarg1;
34127   arg2 = (float)jarg2;
34128   arg3 = (float)jarg3;
34129   {
34130     try {
34131       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34132     } catch (std::out_of_range& e) {
34133       {
34134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34135       };
34136     } catch (std::exception& e) {
34137       {
34138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34139       };
34140     } catch (Dali::DaliException e) {
34141       {
34142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34143       };
34144     } catch (...) {
34145       {
34146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34147       };
34148     }
34149   }
34150
34151 }
34152
34153
34154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34155   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34156   float arg2 ;
34157   float arg3 ;
34158   float arg4 ;
34159
34160   arg1 = (Dali::Actor *)jarg1;
34161   arg2 = (float)jarg2;
34162   arg3 = (float)jarg3;
34163   arg4 = (float)jarg4;
34164   {
34165     try {
34166       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34167     } catch (std::out_of_range& e) {
34168       {
34169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34170       };
34171     } catch (std::exception& e) {
34172       {
34173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34174       };
34175     } catch (Dali::DaliException e) {
34176       {
34177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34178       };
34179     } catch (...) {
34180       {
34181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34182       };
34183     }
34184   }
34185
34186 }
34187
34188
34189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34190   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34191   Dali::Vector2 *arg2 = 0 ;
34192
34193   arg1 = (Dali::Actor *)jarg1;
34194   arg2 = (Dali::Vector2 *)jarg2;
34195   if (!arg2) {
34196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34197     return ;
34198   }
34199   {
34200     try {
34201       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34202     } catch (std::out_of_range& e) {
34203       {
34204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34205       };
34206     } catch (std::exception& e) {
34207       {
34208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34209       };
34210     } catch (Dali::DaliException e) {
34211       {
34212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34213       };
34214     } catch (...) {
34215       {
34216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34217       };
34218     }
34219   }
34220
34221 }
34222
34223
34224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34225   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34226   Dali::Vector3 *arg2 = 0 ;
34227
34228   arg1 = (Dali::Actor *)jarg1;
34229   arg2 = (Dali::Vector3 *)jarg2;
34230   if (!arg2) {
34231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34232     return ;
34233   }
34234   {
34235     try {
34236       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34237     } catch (std::out_of_range& e) {
34238       {
34239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34240       };
34241     } catch (std::exception& e) {
34242       {
34243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34244       };
34245     } catch (Dali::DaliException e) {
34246       {
34247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34248       };
34249     } catch (...) {
34250       {
34251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34252       };
34253     }
34254   }
34255
34256 }
34257
34258
34259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34260   void * jresult ;
34261   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34262   Dali::Vector3 result;
34263
34264   arg1 = (Dali::Actor *)jarg1;
34265   {
34266     try {
34267       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34268     } catch (std::out_of_range& e) {
34269       {
34270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34271       };
34272     } catch (std::exception& e) {
34273       {
34274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34275       };
34276     } catch (Dali::DaliException e) {
34277       {
34278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34279       };
34280     } catch (...) {
34281       {
34282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34283       };
34284     }
34285   }
34286
34287   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34288   return jresult;
34289 }
34290
34291
34292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34293   void * jresult ;
34294   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34295   Dali::Vector3 result;
34296
34297   arg1 = (Dali::Actor *)jarg1;
34298   {
34299     try {
34300       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34301     } catch (std::out_of_range& e) {
34302       {
34303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34304       };
34305     } catch (std::exception& e) {
34306       {
34307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34308       };
34309     } catch (Dali::DaliException e) {
34310       {
34311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34312       };
34313     } catch (...) {
34314       {
34315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34316       };
34317     }
34318   }
34319
34320   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34321   return jresult;
34322 }
34323
34324
34325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34326   void * jresult ;
34327   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34328   Dali::Vector3 result;
34329
34330   arg1 = (Dali::Actor *)jarg1;
34331   {
34332     try {
34333       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34334     } catch (std::out_of_range& e) {
34335       {
34336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34337       };
34338     } catch (std::exception& e) {
34339       {
34340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34341       };
34342     } catch (Dali::DaliException e) {
34343       {
34344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34345       };
34346     } catch (...) {
34347       {
34348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34349       };
34350     }
34351   }
34352
34353   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34354   return jresult;
34355 }
34356
34357
34358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34359   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34360   float arg2 ;
34361   float arg3 ;
34362
34363   arg1 = (Dali::Actor *)jarg1;
34364   arg2 = (float)jarg2;
34365   arg3 = (float)jarg3;
34366   {
34367     try {
34368       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34369     } catch (std::out_of_range& e) {
34370       {
34371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34372       };
34373     } catch (std::exception& e) {
34374       {
34375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34376       };
34377     } catch (Dali::DaliException e) {
34378       {
34379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34380       };
34381     } catch (...) {
34382       {
34383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34384       };
34385     }
34386   }
34387
34388 }
34389
34390
34391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34392   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34393   float arg2 ;
34394   float arg3 ;
34395   float arg4 ;
34396
34397   arg1 = (Dali::Actor *)jarg1;
34398   arg2 = (float)jarg2;
34399   arg3 = (float)jarg3;
34400   arg4 = (float)jarg4;
34401   {
34402     try {
34403       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34404     } catch (std::out_of_range& e) {
34405       {
34406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34407       };
34408     } catch (std::exception& e) {
34409       {
34410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34411       };
34412     } catch (Dali::DaliException e) {
34413       {
34414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34415       };
34416     } catch (...) {
34417       {
34418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34419       };
34420     }
34421   }
34422
34423 }
34424
34425
34426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34427   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34428   Dali::Vector3 *arg2 = 0 ;
34429
34430   arg1 = (Dali::Actor *)jarg1;
34431   arg2 = (Dali::Vector3 *)jarg2;
34432   if (!arg2) {
34433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34434     return ;
34435   }
34436   {
34437     try {
34438       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34439     } catch (std::out_of_range& e) {
34440       {
34441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34442       };
34443     } catch (std::exception& e) {
34444       {
34445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34446       };
34447     } catch (Dali::DaliException e) {
34448       {
34449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34450       };
34451     } catch (...) {
34452       {
34453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34454       };
34455     }
34456   }
34457
34458 }
34459
34460
34461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34462   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34463   float arg2 ;
34464
34465   arg1 = (Dali::Actor *)jarg1;
34466   arg2 = (float)jarg2;
34467   {
34468     try {
34469       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34470     } catch (std::out_of_range& e) {
34471       {
34472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34473       };
34474     } catch (std::exception& e) {
34475       {
34476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34477       };
34478     } catch (Dali::DaliException e) {
34479       {
34480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34481       };
34482     } catch (...) {
34483       {
34484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34485       };
34486     }
34487   }
34488
34489 }
34490
34491
34492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34493   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34494   float arg2 ;
34495
34496   arg1 = (Dali::Actor *)jarg1;
34497   arg2 = (float)jarg2;
34498   {
34499     try {
34500       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34501     } catch (std::out_of_range& e) {
34502       {
34503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34504       };
34505     } catch (std::exception& e) {
34506       {
34507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34508       };
34509     } catch (Dali::DaliException e) {
34510       {
34511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34512       };
34513     } catch (...) {
34514       {
34515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34516       };
34517     }
34518   }
34519
34520 }
34521
34522
34523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34524   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34525   float arg2 ;
34526
34527   arg1 = (Dali::Actor *)jarg1;
34528   arg2 = (float)jarg2;
34529   {
34530     try {
34531       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34532     } catch (std::out_of_range& e) {
34533       {
34534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34535       };
34536     } catch (std::exception& e) {
34537       {
34538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34539       };
34540     } catch (Dali::DaliException e) {
34541       {
34542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34543       };
34544     } catch (...) {
34545       {
34546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34547       };
34548     }
34549   }
34550
34551 }
34552
34553
34554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34555   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34556   Dali::Vector3 *arg2 = 0 ;
34557
34558   arg1 = (Dali::Actor *)jarg1;
34559   arg2 = (Dali::Vector3 *)jarg2;
34560   if (!arg2) {
34561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34562     return ;
34563   }
34564   {
34565     try {
34566       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34567     } catch (std::out_of_range& e) {
34568       {
34569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34570       };
34571     } catch (std::exception& e) {
34572       {
34573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34574       };
34575     } catch (Dali::DaliException e) {
34576       {
34577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34578       };
34579     } catch (...) {
34580       {
34581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34582       };
34583     }
34584   }
34585
34586 }
34587
34588
34589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34590   void * jresult ;
34591   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34592   Dali::Vector3 result;
34593
34594   arg1 = (Dali::Actor *)jarg1;
34595   {
34596     try {
34597       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34598     } catch (std::out_of_range& e) {
34599       {
34600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34601       };
34602     } catch (std::exception& e) {
34603       {
34604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34605       };
34606     } catch (Dali::DaliException e) {
34607       {
34608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34609       };
34610     } catch (...) {
34611       {
34612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34613       };
34614     }
34615   }
34616
34617   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34618   return jresult;
34619 }
34620
34621
34622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34623   void * jresult ;
34624   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34625   Dali::Vector3 result;
34626
34627   arg1 = (Dali::Actor *)jarg1;
34628   {
34629     try {
34630       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34631     } catch (std::out_of_range& e) {
34632       {
34633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34634       };
34635     } catch (std::exception& e) {
34636       {
34637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34638       };
34639     } catch (Dali::DaliException e) {
34640       {
34641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34642       };
34643     } catch (...) {
34644       {
34645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34646       };
34647     }
34648   }
34649
34650   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34651   return jresult;
34652 }
34653
34654
34655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34657   bool arg2 ;
34658
34659   arg1 = (Dali::Actor *)jarg1;
34660   arg2 = jarg2 ? true : false;
34661   {
34662     try {
34663       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
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 unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34687   unsigned int jresult ;
34688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34689   bool result;
34690
34691   arg1 = (Dali::Actor *)jarg1;
34692   {
34693     try {
34694       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
34695     } catch (std::out_of_range& e) {
34696       {
34697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34698       };
34699     } catch (std::exception& e) {
34700       {
34701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34702       };
34703     } catch (Dali::DaliException e) {
34704       {
34705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34706       };
34707     } catch (...) {
34708       {
34709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34710       };
34711     }
34712   }
34713
34714   jresult = result;
34715   return jresult;
34716 }
34717
34718
34719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34720   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34721   Dali::Degree *arg2 = 0 ;
34722   Dali::Vector3 *arg3 = 0 ;
34723
34724   arg1 = (Dali::Actor *)jarg1;
34725   arg2 = (Dali::Degree *)jarg2;
34726   if (!arg2) {
34727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34728     return ;
34729   }
34730   arg3 = (Dali::Vector3 *)jarg3;
34731   if (!arg3) {
34732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34733     return ;
34734   }
34735   {
34736     try {
34737       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34738     } catch (std::out_of_range& e) {
34739       {
34740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34741       };
34742     } catch (std::exception& e) {
34743       {
34744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34745       };
34746     } catch (Dali::DaliException e) {
34747       {
34748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34749       };
34750     } catch (...) {
34751       {
34752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34753       };
34754     }
34755   }
34756
34757 }
34758
34759
34760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34761   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34762   Dali::Radian *arg2 = 0 ;
34763   Dali::Vector3 *arg3 = 0 ;
34764
34765   arg1 = (Dali::Actor *)jarg1;
34766   arg2 = (Dali::Radian *)jarg2;
34767   if (!arg2) {
34768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34769     return ;
34770   }
34771   arg3 = (Dali::Vector3 *)jarg3;
34772   if (!arg3) {
34773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34774     return ;
34775   }
34776   {
34777     try {
34778       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34779     } catch (std::out_of_range& e) {
34780       {
34781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34782       };
34783     } catch (std::exception& e) {
34784       {
34785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34786       };
34787     } catch (Dali::DaliException e) {
34788       {
34789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34790       };
34791     } catch (...) {
34792       {
34793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34794       };
34795     }
34796   }
34797
34798 }
34799
34800
34801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34802   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34803   Dali::Quaternion *arg2 = 0 ;
34804
34805   arg1 = (Dali::Actor *)jarg1;
34806   arg2 = (Dali::Quaternion *)jarg2;
34807   if (!arg2) {
34808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34809     return ;
34810   }
34811   {
34812     try {
34813       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
34814     } catch (std::out_of_range& e) {
34815       {
34816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34817       };
34818     } catch (std::exception& e) {
34819       {
34820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34821       };
34822     } catch (Dali::DaliException e) {
34823       {
34824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34825       };
34826     } catch (...) {
34827       {
34828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34829       };
34830     }
34831   }
34832
34833 }
34834
34835
34836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34837   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34838   Dali::Degree *arg2 = 0 ;
34839   Dali::Vector3 *arg3 = 0 ;
34840
34841   arg1 = (Dali::Actor *)jarg1;
34842   arg2 = (Dali::Degree *)jarg2;
34843   if (!arg2) {
34844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34845     return ;
34846   }
34847   arg3 = (Dali::Vector3 *)jarg3;
34848   if (!arg3) {
34849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34850     return ;
34851   }
34852   {
34853     try {
34854       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34855     } catch (std::out_of_range& e) {
34856       {
34857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34858       };
34859     } catch (std::exception& e) {
34860       {
34861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34862       };
34863     } catch (Dali::DaliException e) {
34864       {
34865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34866       };
34867     } catch (...) {
34868       {
34869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34870       };
34871     }
34872   }
34873
34874 }
34875
34876
34877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34878   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34879   Dali::Radian *arg2 = 0 ;
34880   Dali::Vector3 *arg3 = 0 ;
34881
34882   arg1 = (Dali::Actor *)jarg1;
34883   arg2 = (Dali::Radian *)jarg2;
34884   if (!arg2) {
34885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34886     return ;
34887   }
34888   arg3 = (Dali::Vector3 *)jarg3;
34889   if (!arg3) {
34890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34891     return ;
34892   }
34893   {
34894     try {
34895       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34896     } catch (std::out_of_range& e) {
34897       {
34898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34899       };
34900     } catch (std::exception& e) {
34901       {
34902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34903       };
34904     } catch (Dali::DaliException e) {
34905       {
34906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34907       };
34908     } catch (...) {
34909       {
34910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34911       };
34912     }
34913   }
34914
34915 }
34916
34917
34918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
34919   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34920   Dali::Quaternion *arg2 = 0 ;
34921
34922   arg1 = (Dali::Actor *)jarg1;
34923   arg2 = (Dali::Quaternion *)jarg2;
34924   if (!arg2) {
34925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34926     return ;
34927   }
34928   {
34929     try {
34930       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
34931     } catch (std::out_of_range& e) {
34932       {
34933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34934       };
34935     } catch (std::exception& e) {
34936       {
34937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34938       };
34939     } catch (Dali::DaliException e) {
34940       {
34941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34942       };
34943     } catch (...) {
34944       {
34945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34946       };
34947     }
34948   }
34949
34950 }
34951
34952
34953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
34954   void * jresult ;
34955   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34956   Dali::Quaternion result;
34957
34958   arg1 = (Dali::Actor *)jarg1;
34959   {
34960     try {
34961       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
34962     } catch (std::out_of_range& e) {
34963       {
34964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34965       };
34966     } catch (std::exception& e) {
34967       {
34968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34969       };
34970     } catch (Dali::DaliException e) {
34971       {
34972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34973       };
34974     } catch (...) {
34975       {
34976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34977       };
34978     }
34979   }
34980
34981   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
34982   return jresult;
34983 }
34984
34985
34986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
34987   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34988   bool arg2 ;
34989
34990   arg1 = (Dali::Actor *)jarg1;
34991   arg2 = jarg2 ? true : false;
34992   {
34993     try {
34994       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
34995     } catch (std::out_of_range& e) {
34996       {
34997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34998       };
34999     } catch (std::exception& e) {
35000       {
35001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35002       };
35003     } catch (Dali::DaliException e) {
35004       {
35005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35006       };
35007     } catch (...) {
35008       {
35009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35010       };
35011     }
35012   }
35013
35014 }
35015
35016
35017 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35018   unsigned int jresult ;
35019   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35020   bool result;
35021
35022   arg1 = (Dali::Actor *)jarg1;
35023   {
35024     try {
35025       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35026     } catch (std::out_of_range& e) {
35027       {
35028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35029       };
35030     } catch (std::exception& e) {
35031       {
35032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35033       };
35034     } catch (Dali::DaliException e) {
35035       {
35036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35037       };
35038     } catch (...) {
35039       {
35040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35041       };
35042     }
35043   }
35044
35045   jresult = result;
35046   return jresult;
35047 }
35048
35049
35050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35051   void * jresult ;
35052   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35053   Dali::Quaternion result;
35054
35055   arg1 = (Dali::Actor *)jarg1;
35056   {
35057     try {
35058       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35059     } catch (std::out_of_range& e) {
35060       {
35061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35062       };
35063     } catch (std::exception& e) {
35064       {
35065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35066       };
35067     } catch (Dali::DaliException e) {
35068       {
35069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35070       };
35071     } catch (...) {
35072       {
35073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35074       };
35075     }
35076   }
35077
35078   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35079   return jresult;
35080 }
35081
35082
35083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35084   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35085   float arg2 ;
35086
35087   arg1 = (Dali::Actor *)jarg1;
35088   arg2 = (float)jarg2;
35089   {
35090     try {
35091       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35092     } catch (std::out_of_range& e) {
35093       {
35094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35095       };
35096     } catch (std::exception& e) {
35097       {
35098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35099       };
35100     } catch (Dali::DaliException e) {
35101       {
35102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35103       };
35104     } catch (...) {
35105       {
35106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35107       };
35108     }
35109   }
35110
35111 }
35112
35113
35114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35115   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35116   float arg2 ;
35117   float arg3 ;
35118   float arg4 ;
35119
35120   arg1 = (Dali::Actor *)jarg1;
35121   arg2 = (float)jarg2;
35122   arg3 = (float)jarg3;
35123   arg4 = (float)jarg4;
35124   {
35125     try {
35126       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35127     } catch (std::out_of_range& e) {
35128       {
35129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35130       };
35131     } catch (std::exception& e) {
35132       {
35133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35134       };
35135     } catch (Dali::DaliException e) {
35136       {
35137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35138       };
35139     } catch (...) {
35140       {
35141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35142       };
35143     }
35144   }
35145
35146 }
35147
35148
35149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35150   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35151   Dali::Vector3 *arg2 = 0 ;
35152
35153   arg1 = (Dali::Actor *)jarg1;
35154   arg2 = (Dali::Vector3 *)jarg2;
35155   if (!arg2) {
35156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35157     return ;
35158   }
35159   {
35160     try {
35161       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35162     } catch (std::out_of_range& e) {
35163       {
35164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35165       };
35166     } catch (std::exception& e) {
35167       {
35168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35169       };
35170     } catch (Dali::DaliException e) {
35171       {
35172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35173       };
35174     } catch (...) {
35175       {
35176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35177       };
35178     }
35179   }
35180
35181 }
35182
35183
35184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35185   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35186   Dali::Vector3 *arg2 = 0 ;
35187
35188   arg1 = (Dali::Actor *)jarg1;
35189   arg2 = (Dali::Vector3 *)jarg2;
35190   if (!arg2) {
35191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35192     return ;
35193   }
35194   {
35195     try {
35196       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35197     } catch (std::out_of_range& e) {
35198       {
35199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35200       };
35201     } catch (std::exception& e) {
35202       {
35203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35204       };
35205     } catch (Dali::DaliException e) {
35206       {
35207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35208       };
35209     } catch (...) {
35210       {
35211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35212       };
35213     }
35214   }
35215
35216 }
35217
35218
35219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35220   void * jresult ;
35221   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35222   Dali::Vector3 result;
35223
35224   arg1 = (Dali::Actor *)jarg1;
35225   {
35226     try {
35227       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35228     } catch (std::out_of_range& e) {
35229       {
35230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35231       };
35232     } catch (std::exception& e) {
35233       {
35234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35235       };
35236     } catch (Dali::DaliException e) {
35237       {
35238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35239       };
35240     } catch (...) {
35241       {
35242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35243       };
35244     }
35245   }
35246
35247   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35248   return jresult;
35249 }
35250
35251
35252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35253   void * jresult ;
35254   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35255   Dali::Vector3 result;
35256
35257   arg1 = (Dali::Actor *)jarg1;
35258   {
35259     try {
35260       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35261     } catch (std::out_of_range& e) {
35262       {
35263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35264       };
35265     } catch (std::exception& e) {
35266       {
35267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35268       };
35269     } catch (Dali::DaliException e) {
35270       {
35271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35272       };
35273     } catch (...) {
35274       {
35275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35276       };
35277     }
35278   }
35279
35280   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35281   return jresult;
35282 }
35283
35284
35285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35286   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35287   bool arg2 ;
35288
35289   arg1 = (Dali::Actor *)jarg1;
35290   arg2 = jarg2 ? true : false;
35291   {
35292     try {
35293       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35294     } catch (std::out_of_range& e) {
35295       {
35296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35297       };
35298     } catch (std::exception& e) {
35299       {
35300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35301       };
35302     } catch (Dali::DaliException e) {
35303       {
35304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35305       };
35306     } catch (...) {
35307       {
35308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35309       };
35310     }
35311   }
35312
35313 }
35314
35315
35316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35317   unsigned int jresult ;
35318   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35319   bool result;
35320
35321   arg1 = (Dali::Actor *)jarg1;
35322   {
35323     try {
35324       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35325     } catch (std::out_of_range& e) {
35326       {
35327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35328       };
35329     } catch (std::exception& e) {
35330       {
35331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35332       };
35333     } catch (Dali::DaliException e) {
35334       {
35335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35336       };
35337     } catch (...) {
35338       {
35339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35340       };
35341     }
35342   }
35343
35344   jresult = result;
35345   return jresult;
35346 }
35347
35348
35349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35350   void * jresult ;
35351   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35352   Dali::Matrix result;
35353
35354   arg1 = (Dali::Actor *)jarg1;
35355   {
35356     try {
35357       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35358     } catch (std::out_of_range& e) {
35359       {
35360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35361       };
35362     } catch (std::exception& e) {
35363       {
35364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35365       };
35366     } catch (Dali::DaliException e) {
35367       {
35368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35369       };
35370     } catch (...) {
35371       {
35372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35373       };
35374     }
35375   }
35376
35377   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35378   return jresult;
35379 }
35380
35381
35382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35383   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35384   bool arg2 ;
35385
35386   arg1 = (Dali::Actor *)jarg1;
35387   arg2 = jarg2 ? true : false;
35388   {
35389     try {
35390       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35391     } catch (std::out_of_range& e) {
35392       {
35393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35394       };
35395     } catch (std::exception& e) {
35396       {
35397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35398       };
35399     } catch (Dali::DaliException e) {
35400       {
35401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35402       };
35403     } catch (...) {
35404       {
35405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35406       };
35407     }
35408   }
35409
35410 }
35411
35412
35413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35414   unsigned int jresult ;
35415   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35416   bool result;
35417
35418   arg1 = (Dali::Actor *)jarg1;
35419   {
35420     try {
35421       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35422     } catch (std::out_of_range& e) {
35423       {
35424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35425       };
35426     } catch (std::exception& e) {
35427       {
35428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35429       };
35430     } catch (Dali::DaliException e) {
35431       {
35432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35433       };
35434     } catch (...) {
35435       {
35436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35437       };
35438     }
35439   }
35440
35441   jresult = result;
35442   return jresult;
35443 }
35444
35445
35446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35447   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35448   float arg2 ;
35449
35450   arg1 = (Dali::Actor *)jarg1;
35451   arg2 = (float)jarg2;
35452   {
35453     try {
35454       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
35455     } catch (std::out_of_range& e) {
35456       {
35457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35458       };
35459     } catch (std::exception& e) {
35460       {
35461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35462       };
35463     } catch (Dali::DaliException e) {
35464       {
35465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35466       };
35467     } catch (...) {
35468       {
35469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35470       };
35471     }
35472   }
35473
35474 }
35475
35476
35477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35478   float jresult ;
35479   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35480   float result;
35481
35482   arg1 = (Dali::Actor *)jarg1;
35483   {
35484     try {
35485       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
35486     } catch (std::out_of_range& e) {
35487       {
35488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35489       };
35490     } catch (std::exception& e) {
35491       {
35492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35493       };
35494     } catch (Dali::DaliException e) {
35495       {
35496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35497       };
35498     } catch (...) {
35499       {
35500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35501       };
35502     }
35503   }
35504
35505   jresult = result;
35506   return jresult;
35507 }
35508
35509
35510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35511   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35512   Dali::Vector4 *arg2 = 0 ;
35513
35514   arg1 = (Dali::Actor *)jarg1;
35515   arg2 = (Dali::Vector4 *)jarg2;
35516   if (!arg2) {
35517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35518     return ;
35519   }
35520   {
35521     try {
35522       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35523     } catch (std::out_of_range& e) {
35524       {
35525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35526       };
35527     } catch (std::exception& e) {
35528       {
35529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35530       };
35531     } catch (Dali::DaliException e) {
35532       {
35533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35534       };
35535     } catch (...) {
35536       {
35537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35538       };
35539     }
35540   }
35541
35542 }
35543
35544
35545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35546   void * jresult ;
35547   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35548   Dali::Vector4 result;
35549
35550   arg1 = (Dali::Actor *)jarg1;
35551   {
35552     try {
35553       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35554     } catch (std::out_of_range& e) {
35555       {
35556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35557       };
35558     } catch (std::exception& e) {
35559       {
35560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35561       };
35562     } catch (Dali::DaliException e) {
35563       {
35564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35565       };
35566     } catch (...) {
35567       {
35568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35569       };
35570     }
35571   }
35572
35573   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35574   return jresult;
35575 }
35576
35577
35578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35579   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35580   Dali::ColorMode arg2 ;
35581
35582   arg1 = (Dali::Actor *)jarg1;
35583   arg2 = (Dali::ColorMode)jarg2;
35584   {
35585     try {
35586       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35587     } catch (std::out_of_range& e) {
35588       {
35589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35590       };
35591     } catch (std::exception& e) {
35592       {
35593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35594       };
35595     } catch (Dali::DaliException e) {
35596       {
35597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35598       };
35599     } catch (...) {
35600       {
35601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35602       };
35603     }
35604   }
35605
35606 }
35607
35608
35609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35610   int jresult ;
35611   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35612   Dali::ColorMode result;
35613
35614   arg1 = (Dali::Actor *)jarg1;
35615   {
35616     try {
35617       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
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 = (int)result;
35638   return jresult;
35639 }
35640
35641
35642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35643   void * jresult ;
35644   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35645   Dali::Vector4 result;
35646
35647   arg1 = (Dali::Actor *)jarg1;
35648   {
35649     try {
35650       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35651     } catch (std::out_of_range& e) {
35652       {
35653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35654       };
35655     } catch (std::exception& e) {
35656       {
35657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35658       };
35659     } catch (Dali::DaliException e) {
35660       {
35661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35662       };
35663     } catch (...) {
35664       {
35665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35666       };
35667     }
35668   }
35669
35670   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35671   return jresult;
35672 }
35673
35674
35675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35676   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35677   Dali::DrawMode::Type arg2 ;
35678
35679   arg1 = (Dali::Actor *)jarg1;
35680   arg2 = (Dali::DrawMode::Type)jarg2;
35681   {
35682     try {
35683       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
35684     } catch (std::out_of_range& e) {
35685       {
35686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35687       };
35688     } catch (std::exception& e) {
35689       {
35690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35691       };
35692     } catch (Dali::DaliException e) {
35693       {
35694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35695       };
35696     } catch (...) {
35697       {
35698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35699       };
35700     }
35701   }
35702
35703 }
35704
35705
35706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35707   int jresult ;
35708   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35709   Dali::DrawMode::Type result;
35710
35711   arg1 = (Dali::Actor *)jarg1;
35712   {
35713     try {
35714       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
35715     } catch (std::out_of_range& e) {
35716       {
35717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35718       };
35719     } catch (std::exception& e) {
35720       {
35721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35722       };
35723     } catch (Dali::DaliException e) {
35724       {
35725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35726       };
35727     } catch (...) {
35728       {
35729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35730       };
35731     }
35732   }
35733
35734   jresult = (int)result;
35735   return jresult;
35736 }
35737
35738
35739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35740   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35741   bool arg2 ;
35742
35743   arg1 = (Dali::Actor *)jarg1;
35744   arg2 = jarg2 ? true : false;
35745   {
35746     try {
35747       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
35748     } catch (std::out_of_range& e) {
35749       {
35750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35751       };
35752     } catch (std::exception& e) {
35753       {
35754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35755       };
35756     } catch (Dali::DaliException e) {
35757       {
35758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35759       };
35760     } catch (...) {
35761       {
35762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35763       };
35764     }
35765   }
35766
35767 }
35768
35769
35770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35771   unsigned int jresult ;
35772   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35773   bool result;
35774
35775   arg1 = (Dali::Actor *)jarg1;
35776   {
35777     try {
35778       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
35779     } catch (std::out_of_range& e) {
35780       {
35781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35782       };
35783     } catch (std::exception& e) {
35784       {
35785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35786       };
35787     } catch (Dali::DaliException e) {
35788       {
35789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35790       };
35791     } catch (...) {
35792       {
35793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35794       };
35795     }
35796   }
35797
35798   jresult = result;
35799   return jresult;
35800 }
35801
35802
35803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35804   unsigned int jresult ;
35805   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35806   float *arg2 = 0 ;
35807   float *arg3 = 0 ;
35808   float arg4 ;
35809   float arg5 ;
35810   bool result;
35811
35812   arg1 = (Dali::Actor *)jarg1;
35813   arg2 = (float *)jarg2;
35814   arg3 = (float *)jarg3;
35815   arg4 = (float)jarg4;
35816   arg5 = (float)jarg5;
35817   {
35818     try {
35819       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35820     } catch (std::out_of_range& e) {
35821       {
35822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35823       };
35824     } catch (std::exception& e) {
35825       {
35826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35827       };
35828     } catch (Dali::DaliException e) {
35829       {
35830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35831       };
35832     } catch (...) {
35833       {
35834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35835       };
35836     }
35837   }
35838
35839   jresult = result;
35840   return jresult;
35841 }
35842
35843
35844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
35845   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35846   bool arg2 ;
35847
35848   arg1 = (Dali::Actor *)jarg1;
35849   arg2 = jarg2 ? true : false;
35850   {
35851     try {
35852       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
35853     } catch (std::out_of_range& e) {
35854       {
35855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35856       };
35857     } catch (std::exception& e) {
35858       {
35859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35860       };
35861     } catch (Dali::DaliException e) {
35862       {
35863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35864       };
35865     } catch (...) {
35866       {
35867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35868       };
35869     }
35870   }
35871
35872 }
35873
35874
35875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
35876   unsigned int jresult ;
35877   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35878   bool result;
35879
35880   arg1 = (Dali::Actor *)jarg1;
35881   {
35882     try {
35883       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
35884     } catch (std::out_of_range& e) {
35885       {
35886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35887       };
35888     } catch (std::exception& e) {
35889       {
35890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35891       };
35892     } catch (Dali::DaliException e) {
35893       {
35894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35895       };
35896     } catch (...) {
35897       {
35898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35899       };
35900     }
35901   }
35902
35903   jresult = result;
35904   return jresult;
35905 }
35906
35907
35908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
35909   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35910   bool arg2 ;
35911
35912   arg1 = (Dali::Actor *)jarg1;
35913   arg2 = jarg2 ? true : false;
35914   {
35915     try {
35916       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
35917     } catch (std::out_of_range& e) {
35918       {
35919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35920       };
35921     } catch (std::exception& e) {
35922       {
35923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35924       };
35925     } catch (Dali::DaliException e) {
35926       {
35927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35928       };
35929     } catch (...) {
35930       {
35931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35932       };
35933     }
35934   }
35935
35936 }
35937
35938
35939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
35940   unsigned int jresult ;
35941   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35942   bool result;
35943
35944   arg1 = (Dali::Actor *)jarg1;
35945   {
35946     try {
35947       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
35948     } catch (std::out_of_range& e) {
35949       {
35950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35951       };
35952     } catch (std::exception& e) {
35953       {
35954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35955       };
35956     } catch (Dali::DaliException e) {
35957       {
35958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35959       };
35960     } catch (...) {
35961       {
35962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35963       };
35964     }
35965   }
35966
35967   jresult = result;
35968   return jresult;
35969 }
35970
35971
35972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
35973   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35974   Dali::ResizePolicy::Type arg2 ;
35975   Dali::Dimension::Type arg3 ;
35976
35977   arg1 = (Dali::Actor *)jarg1;
35978   arg2 = (Dali::ResizePolicy::Type)jarg2;
35979   arg3 = (Dali::Dimension::Type)jarg3;
35980   {
35981     try {
35982       (arg1)->SetResizePolicy(arg2,arg3);
35983     } catch (std::out_of_range& e) {
35984       {
35985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35986       };
35987     } catch (std::exception& e) {
35988       {
35989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35990       };
35991     } catch (Dali::DaliException e) {
35992       {
35993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35994       };
35995     } catch (...) {
35996       {
35997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35998       };
35999     }
36000   }
36001
36002 }
36003
36004
36005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36006   int jresult ;
36007   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36008   Dali::Dimension::Type arg2 ;
36009   Dali::ResizePolicy::Type result;
36010
36011   arg1 = (Dali::Actor *)jarg1;
36012   arg2 = (Dali::Dimension::Type)jarg2;
36013   {
36014     try {
36015       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36016     } catch (std::out_of_range& e) {
36017       {
36018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36019       };
36020     } catch (std::exception& e) {
36021       {
36022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36023       };
36024     } catch (Dali::DaliException e) {
36025       {
36026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36027       };
36028     } catch (...) {
36029       {
36030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36031       };
36032     }
36033   }
36034
36035   jresult = (int)result;
36036   return jresult;
36037 }
36038
36039
36040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36041   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36042   Dali::SizeScalePolicy::Type arg2 ;
36043
36044   arg1 = (Dali::Actor *)jarg1;
36045   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36046   {
36047     try {
36048       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36049     } catch (std::out_of_range& e) {
36050       {
36051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36052       };
36053     } catch (std::exception& e) {
36054       {
36055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36056       };
36057     } catch (Dali::DaliException e) {
36058       {
36059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36060       };
36061     } catch (...) {
36062       {
36063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36064       };
36065     }
36066   }
36067
36068 }
36069
36070
36071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36072   int jresult ;
36073   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36074   Dali::SizeScalePolicy::Type result;
36075
36076   arg1 = (Dali::Actor *)jarg1;
36077   {
36078     try {
36079       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
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 = (int)result;
36100   return jresult;
36101 }
36102
36103
36104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36105   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36106   Dali::Vector3 *arg2 = 0 ;
36107
36108   arg1 = (Dali::Actor *)jarg1;
36109   arg2 = (Dali::Vector3 *)jarg2;
36110   if (!arg2) {
36111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36112     return ;
36113   }
36114   {
36115     try {
36116       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36117     } catch (std::out_of_range& e) {
36118       {
36119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36120       };
36121     } catch (std::exception& e) {
36122       {
36123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36124       };
36125     } catch (Dali::DaliException e) {
36126       {
36127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36128       };
36129     } catch (...) {
36130       {
36131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36132       };
36133     }
36134   }
36135
36136 }
36137
36138
36139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36140   void * jresult ;
36141   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36142   Dali::Vector3 result;
36143
36144   arg1 = (Dali::Actor *)jarg1;
36145   {
36146     try {
36147       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36148     } catch (std::out_of_range& e) {
36149       {
36150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36151       };
36152     } catch (std::exception& e) {
36153       {
36154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36155       };
36156     } catch (Dali::DaliException e) {
36157       {
36158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36159       };
36160     } catch (...) {
36161       {
36162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36163       };
36164     }
36165   }
36166
36167   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36168   return jresult;
36169 }
36170
36171
36172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36173   float jresult ;
36174   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36175   float arg2 ;
36176   float result;
36177
36178   arg1 = (Dali::Actor *)jarg1;
36179   arg2 = (float)jarg2;
36180   {
36181     try {
36182       result = (float)(arg1)->GetHeightForWidth(arg2);
36183     } catch (std::out_of_range& e) {
36184       {
36185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36186       };
36187     } catch (std::exception& e) {
36188       {
36189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36190       };
36191     } catch (Dali::DaliException e) {
36192       {
36193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36194       };
36195     } catch (...) {
36196       {
36197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36198       };
36199     }
36200   }
36201
36202   jresult = result;
36203   return jresult;
36204 }
36205
36206
36207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36208   float jresult ;
36209   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36210   float arg2 ;
36211   float result;
36212
36213   arg1 = (Dali::Actor *)jarg1;
36214   arg2 = (float)jarg2;
36215   {
36216     try {
36217       result = (float)(arg1)->GetWidthForHeight(arg2);
36218     } catch (std::out_of_range& e) {
36219       {
36220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36221       };
36222     } catch (std::exception& e) {
36223       {
36224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36225       };
36226     } catch (Dali::DaliException e) {
36227       {
36228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36229       };
36230     } catch (...) {
36231       {
36232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36233       };
36234     }
36235   }
36236
36237   jresult = result;
36238   return jresult;
36239 }
36240
36241
36242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36243   float jresult ;
36244   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36245   Dali::Dimension::Type arg2 ;
36246   float result;
36247
36248   arg1 = (Dali::Actor *)jarg1;
36249   arg2 = (Dali::Dimension::Type)jarg2;
36250   {
36251     try {
36252       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36253     } catch (std::out_of_range& e) {
36254       {
36255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36256       };
36257     } catch (std::exception& e) {
36258       {
36259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36260       };
36261     } catch (Dali::DaliException e) {
36262       {
36263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36264       };
36265     } catch (...) {
36266       {
36267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36268       };
36269     }
36270   }
36271
36272   jresult = result;
36273   return jresult;
36274 }
36275
36276
36277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36278   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36279   Dali::Padding *arg2 = 0 ;
36280
36281   arg1 = (Dali::Actor *)jarg1;
36282   arg2 = (Dali::Padding *)jarg2;
36283   if (!arg2) {
36284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36285     return ;
36286   }
36287   {
36288     try {
36289       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36290     } catch (std::out_of_range& e) {
36291       {
36292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36293       };
36294     } catch (std::exception& e) {
36295       {
36296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36297       };
36298     } catch (Dali::DaliException e) {
36299       {
36300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36301       };
36302     } catch (...) {
36303       {
36304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36305       };
36306     }
36307   }
36308
36309 }
36310
36311
36312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36313   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36314   Dali::Padding *arg2 = 0 ;
36315
36316   arg1 = (Dali::Actor *)jarg1;
36317   arg2 = (Dali::Padding *)jarg2;
36318   if (!arg2) {
36319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36320     return ;
36321   }
36322   {
36323     try {
36324       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36325     } catch (std::out_of_range& e) {
36326       {
36327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36328       };
36329     } catch (std::exception& e) {
36330       {
36331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36332       };
36333     } catch (Dali::DaliException e) {
36334       {
36335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36336       };
36337     } catch (...) {
36338       {
36339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36340       };
36341     }
36342   }
36343
36344 }
36345
36346
36347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36348   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36349   Dali::Vector2 *arg2 = 0 ;
36350
36351   arg1 = (Dali::Actor *)jarg1;
36352   arg2 = (Dali::Vector2 *)jarg2;
36353   if (!arg2) {
36354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36355     return ;
36356   }
36357   {
36358     try {
36359       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36360     } catch (std::out_of_range& e) {
36361       {
36362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36363       };
36364     } catch (std::exception& e) {
36365       {
36366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36367       };
36368     } catch (Dali::DaliException e) {
36369       {
36370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36371       };
36372     } catch (...) {
36373       {
36374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36375       };
36376     }
36377   }
36378
36379 }
36380
36381
36382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36383   void * jresult ;
36384   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36385   Dali::Vector2 result;
36386
36387   arg1 = (Dali::Actor *)jarg1;
36388   {
36389     try {
36390       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36391     } catch (std::out_of_range& e) {
36392       {
36393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36394       };
36395     } catch (std::exception& e) {
36396       {
36397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36398       };
36399     } catch (Dali::DaliException e) {
36400       {
36401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36402       };
36403     } catch (...) {
36404       {
36405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36406       };
36407     }
36408   }
36409
36410   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36411   return jresult;
36412 }
36413
36414
36415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36416   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36417   Dali::Vector2 *arg2 = 0 ;
36418
36419   arg1 = (Dali::Actor *)jarg1;
36420   arg2 = (Dali::Vector2 *)jarg2;
36421   if (!arg2) {
36422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36423     return ;
36424   }
36425   {
36426     try {
36427       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36428     } catch (std::out_of_range& e) {
36429       {
36430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36431       };
36432     } catch (std::exception& e) {
36433       {
36434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36435       };
36436     } catch (Dali::DaliException e) {
36437       {
36438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36439       };
36440     } catch (...) {
36441       {
36442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36443       };
36444     }
36445   }
36446
36447 }
36448
36449
36450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36451   void * jresult ;
36452   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36453   Dali::Vector2 result;
36454
36455   arg1 = (Dali::Actor *)jarg1;
36456   {
36457     try {
36458       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36459     } catch (std::out_of_range& e) {
36460       {
36461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36462       };
36463     } catch (std::exception& e) {
36464       {
36465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36466       };
36467     } catch (Dali::DaliException e) {
36468       {
36469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36470       };
36471     } catch (...) {
36472       {
36473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36474       };
36475     }
36476   }
36477
36478   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36479   return jresult;
36480 }
36481
36482
36483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36484   int jresult ;
36485   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36486   int result;
36487
36488   arg1 = (Dali::Actor *)jarg1;
36489   {
36490     try {
36491       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
36492       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36493     } catch (std::out_of_range& e) {
36494       {
36495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36496       };
36497     } catch (std::exception& e) {
36498       {
36499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36500       };
36501     } catch (Dali::DaliException e) {
36502       {
36503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36504       };
36505     } catch (...) {
36506       {
36507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36508       };
36509     }
36510   }
36511
36512   jresult = result;
36513   return jresult;
36514 }
36515
36516
36517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36518   unsigned int jresult ;
36519   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36520   Dali::Renderer *arg2 = 0 ;
36521   unsigned int result;
36522
36523   arg1 = (Dali::Actor *)jarg1;
36524   arg2 = (Dali::Renderer *)jarg2;
36525   if (!arg2) {
36526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36527     return 0;
36528   }
36529   {
36530     try {
36531       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36532     } catch (std::out_of_range& e) {
36533       {
36534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36535       };
36536     } catch (std::exception& e) {
36537       {
36538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36539       };
36540     } catch (Dali::DaliException e) {
36541       {
36542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36543       };
36544     } catch (...) {
36545       {
36546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36547       };
36548     }
36549   }
36550
36551   jresult = result;
36552   return jresult;
36553 }
36554
36555
36556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36557   unsigned int jresult ;
36558   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36559   unsigned int result;
36560
36561   arg1 = (Dali::Actor *)jarg1;
36562   {
36563     try {
36564       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36565     } catch (std::out_of_range& e) {
36566       {
36567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36568       };
36569     } catch (std::exception& e) {
36570       {
36571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36572       };
36573     } catch (Dali::DaliException e) {
36574       {
36575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36576       };
36577     } catch (...) {
36578       {
36579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36580       };
36581     }
36582   }
36583
36584   jresult = result;
36585   return jresult;
36586 }
36587
36588
36589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36590   void * jresult ;
36591   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36592   unsigned int arg2 ;
36593   Dali::Renderer result;
36594
36595   arg1 = (Dali::Actor *)jarg1;
36596   arg2 = (unsigned int)jarg2;
36597   {
36598     try {
36599       result = (arg1)->GetRendererAt(arg2);
36600     } catch (std::out_of_range& e) {
36601       {
36602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36603       };
36604     } catch (std::exception& e) {
36605       {
36606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36607       };
36608     } catch (Dali::DaliException e) {
36609       {
36610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36611       };
36612     } catch (...) {
36613       {
36614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36615       };
36616     }
36617   }
36618
36619   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36620   return jresult;
36621 }
36622
36623
36624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36625   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36626   Dali::Renderer *arg2 = 0 ;
36627
36628   arg1 = (Dali::Actor *)jarg1;
36629   arg2 = (Dali::Renderer *)jarg2;
36630   if (!arg2) {
36631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36632     return ;
36633   }
36634   {
36635     try {
36636       (arg1)->RemoveRenderer(*arg2);
36637     } catch (std::out_of_range& e) {
36638       {
36639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36640       };
36641     } catch (std::exception& e) {
36642       {
36643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36644       };
36645     } catch (Dali::DaliException e) {
36646       {
36647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36648       };
36649     } catch (...) {
36650       {
36651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36652       };
36653     }
36654   }
36655
36656 }
36657
36658
36659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36660   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36661   unsigned int arg2 ;
36662
36663   arg1 = (Dali::Actor *)jarg1;
36664   arg2 = (unsigned int)jarg2;
36665   {
36666     try {
36667       (arg1)->RemoveRenderer(arg2);
36668     } catch (std::out_of_range& e) {
36669       {
36670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36671       };
36672     } catch (std::exception& e) {
36673       {
36674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36675       };
36676     } catch (Dali::DaliException e) {
36677       {
36678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36679       };
36680     } catch (...) {
36681       {
36682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36683       };
36684     }
36685   }
36686
36687 }
36688
36689
36690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36691   void * jresult ;
36692   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36693   Dali::Actor::TouchSignalType *result = 0 ;
36694
36695   arg1 = (Dali::Actor *)jarg1;
36696   {
36697     try {
36698       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36699     } catch (std::out_of_range& e) {
36700       {
36701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36702       };
36703     } catch (std::exception& e) {
36704       {
36705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36706       };
36707     } catch (Dali::DaliException e) {
36708       {
36709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36710       };
36711     } catch (...) {
36712       {
36713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36714       };
36715     }
36716   }
36717
36718   jresult = (void *)result;
36719   return jresult;
36720 }
36721
36722
36723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36724   void * jresult ;
36725   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36726   Dali::Actor::TouchDataSignalType *result = 0 ;
36727
36728   arg1 = (Dali::Actor *)jarg1;
36729   {
36730     try {
36731       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36732     } catch (std::out_of_range& e) {
36733       {
36734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36735       };
36736     } catch (std::exception& e) {
36737       {
36738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36739       };
36740     } catch (Dali::DaliException e) {
36741       {
36742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36743       };
36744     } catch (...) {
36745       {
36746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36747       };
36748     }
36749   }
36750
36751   jresult = (void *)result;
36752   return jresult;
36753 }
36754
36755
36756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36757   void * jresult ;
36758   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36759   Dali::Actor::HoverSignalType *result = 0 ;
36760
36761   arg1 = (Dali::Actor *)jarg1;
36762   {
36763     try {
36764       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36765     } catch (std::out_of_range& e) {
36766       {
36767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36768       };
36769     } catch (std::exception& e) {
36770       {
36771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36772       };
36773     } catch (Dali::DaliException e) {
36774       {
36775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36776       };
36777     } catch (...) {
36778       {
36779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36780       };
36781     }
36782   }
36783
36784   jresult = (void *)result;
36785   return jresult;
36786 }
36787
36788
36789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36790   void * jresult ;
36791   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36792   Dali::Actor::WheelEventSignalType *result = 0 ;
36793
36794   arg1 = (Dali::Actor *)jarg1;
36795   {
36796     try {
36797       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36798     } catch (std::out_of_range& e) {
36799       {
36800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36801       };
36802     } catch (std::exception& e) {
36803       {
36804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36805       };
36806     } catch (Dali::DaliException e) {
36807       {
36808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36809       };
36810     } catch (...) {
36811       {
36812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36813       };
36814     }
36815   }
36816
36817   jresult = (void *)result;
36818   return jresult;
36819 }
36820
36821
36822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
36823   void * jresult ;
36824   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36825   Dali::Actor::OnStageSignalType *result = 0 ;
36826
36827   arg1 = (Dali::Actor *)jarg1;
36828   {
36829     try {
36830       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
36831     } catch (std::out_of_range& e) {
36832       {
36833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36834       };
36835     } catch (std::exception& e) {
36836       {
36837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36838       };
36839     } catch (Dali::DaliException e) {
36840       {
36841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36842       };
36843     } catch (...) {
36844       {
36845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36846       };
36847     }
36848   }
36849
36850   jresult = (void *)result;
36851   return jresult;
36852 }
36853
36854
36855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
36856   void * jresult ;
36857   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36858   Dali::Actor::OffStageSignalType *result = 0 ;
36859
36860   arg1 = (Dali::Actor *)jarg1;
36861   {
36862     try {
36863       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
36864     } catch (std::out_of_range& e) {
36865       {
36866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36867       };
36868     } catch (std::exception& e) {
36869       {
36870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36871       };
36872     } catch (Dali::DaliException e) {
36873       {
36874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36875       };
36876     } catch (...) {
36877       {
36878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36879       };
36880     }
36881   }
36882
36883   jresult = (void *)result;
36884   return jresult;
36885 }
36886
36887
36888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
36889   void * jresult ;
36890   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36891   Dali::Actor::OnRelayoutSignalType *result = 0 ;
36892
36893   arg1 = (Dali::Actor *)jarg1;
36894   {
36895     try {
36896       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
36897     } catch (std::out_of_range& e) {
36898       {
36899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36900       };
36901     } catch (std::exception& e) {
36902       {
36903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36904       };
36905     } catch (Dali::DaliException e) {
36906       {
36907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36908       };
36909     } catch (...) {
36910       {
36911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36912       };
36913     }
36914   }
36915
36916   jresult = (void *)result;
36917   return jresult;
36918 }
36919
36920
36921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
36922   Dali::Actor *arg1 = 0 ;
36923
36924   arg1 = (Dali::Actor *)jarg1;
36925   if (!arg1) {
36926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36927     return ;
36928   }
36929   {
36930     try {
36931       Dali::UnparentAndReset(*arg1);
36932     } catch (std::out_of_range& e) {
36933       {
36934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36935       };
36936     } catch (std::exception& e) {
36937       {
36938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36939       };
36940     } catch (Dali::DaliException e) {
36941       {
36942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36943       };
36944     } catch (...) {
36945       {
36946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36947       };
36948     }
36949   }
36950
36951 }
36952
36953
36954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
36955   int jresult ;
36956   int result;
36957
36958   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
36959   jresult = (int)result;
36960   return jresult;
36961 }
36962
36963
36964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
36965   int jresult ;
36966   int result;
36967
36968   result = (int)Dali::Layer::Property::CLIPPING_BOX;
36969   jresult = (int)result;
36970   return jresult;
36971 }
36972
36973
36974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
36975   int jresult ;
36976   int result;
36977
36978   result = (int)Dali::Layer::Property::BEHAVIOR;
36979   jresult = (int)result;
36980   return jresult;
36981 }
36982
36983
36984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
36985   void * jresult ;
36986   Dali::Layer::Property *result = 0 ;
36987
36988   {
36989     try {
36990       result = (Dali::Layer::Property *)new Dali::Layer::Property();
36991     } catch (std::out_of_range& e) {
36992       {
36993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36994       };
36995     } catch (std::exception& e) {
36996       {
36997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36998       };
36999     } catch (Dali::DaliException e) {
37000       {
37001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37002       };
37003     } catch (...) {
37004       {
37005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37006       };
37007     }
37008   }
37009
37010   jresult = (void *)result;
37011   return jresult;
37012 }
37013
37014
37015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37016   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37017
37018   arg1 = (Dali::Layer::Property *)jarg1;
37019   {
37020     try {
37021       delete arg1;
37022     } catch (std::out_of_range& e) {
37023       {
37024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37025       };
37026     } catch (std::exception& e) {
37027       {
37028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37029       };
37030     } catch (Dali::DaliException e) {
37031       {
37032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37033       };
37034     } catch (...) {
37035       {
37036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37037       };
37038     }
37039   }
37040
37041 }
37042
37043
37044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37045   void * jresult ;
37046   Dali::Layer *result = 0 ;
37047
37048   {
37049     try {
37050       result = (Dali::Layer *)new Dali::Layer();
37051     } catch (std::out_of_range& e) {
37052       {
37053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37054       };
37055     } catch (std::exception& e) {
37056       {
37057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37058       };
37059     } catch (Dali::DaliException e) {
37060       {
37061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37062       };
37063     } catch (...) {
37064       {
37065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37066       };
37067     }
37068   }
37069
37070   jresult = (void *)result;
37071   return jresult;
37072 }
37073
37074
37075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37076   void * jresult ;
37077   Dali::Layer result;
37078
37079   {
37080     try {
37081       result = Dali::Layer::New();
37082     } catch (std::out_of_range& e) {
37083       {
37084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37085       };
37086     } catch (std::exception& e) {
37087       {
37088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37089       };
37090     } catch (Dali::DaliException e) {
37091       {
37092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37093       };
37094     } catch (...) {
37095       {
37096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37097       };
37098     }
37099   }
37100
37101   jresult = new Dali::Layer((const Dali::Layer &)result);
37102   return jresult;
37103 }
37104
37105
37106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37107   void * jresult ;
37108   Dali::BaseHandle arg1 ;
37109   Dali::BaseHandle *argp1 ;
37110   Dali::Layer result;
37111
37112   argp1 = (Dali::BaseHandle *)jarg1;
37113   if (!argp1) {
37114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37115     return 0;
37116   }
37117   arg1 = *argp1;
37118   {
37119     try {
37120       result = Dali::Layer::DownCast(arg1);
37121     } catch (std::out_of_range& e) {
37122       {
37123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37124       };
37125     } catch (std::exception& e) {
37126       {
37127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37128       };
37129     } catch (Dali::DaliException e) {
37130       {
37131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37132       };
37133     } catch (...) {
37134       {
37135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37136       };
37137     }
37138   }
37139
37140   jresult = new Dali::Layer((const Dali::Layer &)result);
37141   return jresult;
37142 }
37143
37144
37145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37146   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37147
37148   arg1 = (Dali::Layer *)jarg1;
37149   {
37150     try {
37151       delete arg1;
37152     } catch (std::out_of_range& e) {
37153       {
37154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37155       };
37156     } catch (std::exception& e) {
37157       {
37158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37159       };
37160     } catch (Dali::DaliException e) {
37161       {
37162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37163       };
37164     } catch (...) {
37165       {
37166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37167       };
37168     }
37169   }
37170
37171 }
37172
37173
37174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37175   void * jresult ;
37176   Dali::Layer *arg1 = 0 ;
37177   Dali::Layer *result = 0 ;
37178
37179   arg1 = (Dali::Layer *)jarg1;
37180   if (!arg1) {
37181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37182     return 0;
37183   }
37184   {
37185     try {
37186       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37187     } catch (std::out_of_range& e) {
37188       {
37189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37190       };
37191     } catch (std::exception& e) {
37192       {
37193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37194       };
37195     } catch (Dali::DaliException e) {
37196       {
37197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37198       };
37199     } catch (...) {
37200       {
37201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37202       };
37203     }
37204   }
37205
37206   jresult = (void *)result;
37207   return jresult;
37208 }
37209
37210
37211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37212   void * jresult ;
37213   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37214   Dali::Layer *arg2 = 0 ;
37215   Dali::Layer *result = 0 ;
37216
37217   arg1 = (Dali::Layer *)jarg1;
37218   arg2 = (Dali::Layer *)jarg2;
37219   if (!arg2) {
37220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37221     return 0;
37222   }
37223   {
37224     try {
37225       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37226     } catch (std::out_of_range& e) {
37227       {
37228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37229       };
37230     } catch (std::exception& e) {
37231       {
37232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37233       };
37234     } catch (Dali::DaliException e) {
37235       {
37236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37237       };
37238     } catch (...) {
37239       {
37240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37241       };
37242     }
37243   }
37244
37245   jresult = (void *)result;
37246   return jresult;
37247 }
37248
37249
37250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37251   unsigned int jresult ;
37252   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37253   unsigned int result;
37254
37255   arg1 = (Dali::Layer *)jarg1;
37256   {
37257     try {
37258       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37259     } catch (std::out_of_range& e) {
37260       {
37261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37262       };
37263     } catch (std::exception& e) {
37264       {
37265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37266       };
37267     } catch (Dali::DaliException e) {
37268       {
37269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37270       };
37271     } catch (...) {
37272       {
37273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37274       };
37275     }
37276   }
37277
37278   jresult = result;
37279   return jresult;
37280 }
37281
37282
37283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37284   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37285
37286   arg1 = (Dali::Layer *)jarg1;
37287   {
37288     try {
37289       (arg1)->Raise();
37290     } catch (std::out_of_range& e) {
37291       {
37292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37293       };
37294     } catch (std::exception& e) {
37295       {
37296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37297       };
37298     } catch (Dali::DaliException e) {
37299       {
37300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37301       };
37302     } catch (...) {
37303       {
37304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37305       };
37306     }
37307   }
37308
37309 }
37310
37311
37312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37313   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37314
37315   arg1 = (Dali::Layer *)jarg1;
37316   {
37317     try {
37318       (arg1)->Lower();
37319     } catch (std::out_of_range& e) {
37320       {
37321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37322       };
37323     } catch (std::exception& e) {
37324       {
37325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37326       };
37327     } catch (Dali::DaliException e) {
37328       {
37329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37330       };
37331     } catch (...) {
37332       {
37333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37334       };
37335     }
37336   }
37337
37338 }
37339
37340
37341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37342   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37343   Dali::Layer arg2 ;
37344   Dali::Layer *argp2 ;
37345
37346   arg1 = (Dali::Layer *)jarg1;
37347   argp2 = (Dali::Layer *)jarg2;
37348   if (!argp2) {
37349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37350     return ;
37351   }
37352   arg2 = *argp2;
37353   {
37354     try {
37355       (arg1)->RaiseAbove(arg2);
37356     } catch (std::out_of_range& e) {
37357       {
37358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37359       };
37360     } catch (std::exception& e) {
37361       {
37362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37363       };
37364     } catch (Dali::DaliException e) {
37365       {
37366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37367       };
37368     } catch (...) {
37369       {
37370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37371       };
37372     }
37373   }
37374
37375 }
37376
37377
37378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37379   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37380   Dali::Layer arg2 ;
37381   Dali::Layer *argp2 ;
37382
37383   arg1 = (Dali::Layer *)jarg1;
37384   argp2 = (Dali::Layer *)jarg2;
37385   if (!argp2) {
37386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37387     return ;
37388   }
37389   arg2 = *argp2;
37390   {
37391     try {
37392       (arg1)->LowerBelow(arg2);
37393     } catch (std::out_of_range& e) {
37394       {
37395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37396       };
37397     } catch (std::exception& e) {
37398       {
37399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37400       };
37401     } catch (Dali::DaliException e) {
37402       {
37403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37404       };
37405     } catch (...) {
37406       {
37407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37408       };
37409     }
37410   }
37411
37412 }
37413
37414
37415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37416   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37417
37418   arg1 = (Dali::Layer *)jarg1;
37419   {
37420     try {
37421       (arg1)->RaiseToTop();
37422     } catch (std::out_of_range& e) {
37423       {
37424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37425       };
37426     } catch (std::exception& e) {
37427       {
37428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37429       };
37430     } catch (Dali::DaliException e) {
37431       {
37432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37433       };
37434     } catch (...) {
37435       {
37436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37437       };
37438     }
37439   }
37440
37441 }
37442
37443
37444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37445   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37446
37447   arg1 = (Dali::Layer *)jarg1;
37448   {
37449     try {
37450       (arg1)->LowerToBottom();
37451     } catch (std::out_of_range& e) {
37452       {
37453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37454       };
37455     } catch (std::exception& e) {
37456       {
37457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37458       };
37459     } catch (Dali::DaliException e) {
37460       {
37461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37462       };
37463     } catch (...) {
37464       {
37465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37466       };
37467     }
37468   }
37469
37470 }
37471
37472
37473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37474   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37475   Dali::Layer arg2 ;
37476   Dali::Layer *argp2 ;
37477
37478   arg1 = (Dali::Layer *)jarg1;
37479   argp2 = (Dali::Layer *)jarg2;
37480   if (!argp2) {
37481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37482     return ;
37483   }
37484   arg2 = *argp2;
37485   {
37486     try {
37487       (arg1)->MoveAbove(arg2);
37488     } catch (std::out_of_range& e) {
37489       {
37490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37491       };
37492     } catch (std::exception& e) {
37493       {
37494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37495       };
37496     } catch (Dali::DaliException e) {
37497       {
37498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37499       };
37500     } catch (...) {
37501       {
37502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37503       };
37504     }
37505   }
37506
37507 }
37508
37509
37510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37511   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37512   Dali::Layer arg2 ;
37513   Dali::Layer *argp2 ;
37514
37515   arg1 = (Dali::Layer *)jarg1;
37516   argp2 = (Dali::Layer *)jarg2;
37517   if (!argp2) {
37518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37519     return ;
37520   }
37521   arg2 = *argp2;
37522   {
37523     try {
37524       (arg1)->MoveBelow(arg2);
37525     } catch (std::out_of_range& e) {
37526       {
37527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37528       };
37529     } catch (std::exception& e) {
37530       {
37531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37532       };
37533     } catch (Dali::DaliException e) {
37534       {
37535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37536       };
37537     } catch (...) {
37538       {
37539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37540       };
37541     }
37542   }
37543
37544 }
37545
37546
37547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37548   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37549   Dali::Layer::Behavior arg2 ;
37550
37551   arg1 = (Dali::Layer *)jarg1;
37552   arg2 = (Dali::Layer::Behavior)jarg2;
37553   {
37554     try {
37555       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
37556     } catch (std::out_of_range& e) {
37557       {
37558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37559       };
37560     } catch (std::exception& e) {
37561       {
37562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37563       };
37564     } catch (Dali::DaliException e) {
37565       {
37566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37567       };
37568     } catch (...) {
37569       {
37570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37571       };
37572     }
37573   }
37574
37575 }
37576
37577
37578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37579   int jresult ;
37580   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37581   Dali::Layer::Behavior result;
37582
37583   arg1 = (Dali::Layer *)jarg1;
37584   {
37585     try {
37586       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
37587     } catch (std::out_of_range& e) {
37588       {
37589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37590       };
37591     } catch (std::exception& e) {
37592       {
37593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37594       };
37595     } catch (Dali::DaliException e) {
37596       {
37597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37598       };
37599     } catch (...) {
37600       {
37601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37602       };
37603     }
37604   }
37605
37606   jresult = (int)result;
37607   return jresult;
37608 }
37609
37610
37611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37612   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37613   bool arg2 ;
37614
37615   arg1 = (Dali::Layer *)jarg1;
37616   arg2 = jarg2 ? true : false;
37617   {
37618     try {
37619       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
37620     } catch (std::out_of_range& e) {
37621       {
37622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37623       };
37624     } catch (std::exception& e) {
37625       {
37626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37627       };
37628     } catch (Dali::DaliException e) {
37629       {
37630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37631       };
37632     } catch (...) {
37633       {
37634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37635       };
37636     }
37637   }
37638
37639 }
37640
37641
37642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37643   unsigned int jresult ;
37644   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37645   bool result;
37646
37647   arg1 = (Dali::Layer *)jarg1;
37648   {
37649     try {
37650       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
37651     } catch (std::out_of_range& e) {
37652       {
37653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37654       };
37655     } catch (std::exception& e) {
37656       {
37657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37658       };
37659     } catch (Dali::DaliException e) {
37660       {
37661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37662       };
37663     } catch (...) {
37664       {
37665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37666       };
37667     }
37668   }
37669
37670   jresult = result;
37671   return jresult;
37672 }
37673
37674
37675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37676   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37677   int arg2 ;
37678   int arg3 ;
37679   int arg4 ;
37680   int arg5 ;
37681
37682   arg1 = (Dali::Layer *)jarg1;
37683   arg2 = (int)jarg2;
37684   arg3 = (int)jarg3;
37685   arg4 = (int)jarg4;
37686   arg5 = (int)jarg5;
37687   {
37688     try {
37689       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
37690     } catch (std::out_of_range& e) {
37691       {
37692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37693       };
37694     } catch (std::exception& e) {
37695       {
37696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37697       };
37698     } catch (Dali::DaliException e) {
37699       {
37700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37701       };
37702     } catch (...) {
37703       {
37704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37705       };
37706     }
37707   }
37708
37709 }
37710
37711
37712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37713   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37714   Dali::ClippingBox arg2 ;
37715   Dali::ClippingBox *argp2 ;
37716
37717   arg1 = (Dali::Layer *)jarg1;
37718   argp2 = (Dali::ClippingBox *)jarg2;
37719   if (!argp2) {
37720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37721     return ;
37722   }
37723   arg2 = *argp2;
37724   {
37725     try {
37726       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
37727     } catch (std::out_of_range& e) {
37728       {
37729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37730       };
37731     } catch (std::exception& e) {
37732       {
37733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37734       };
37735     } catch (Dali::DaliException e) {
37736       {
37737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37738       };
37739     } catch (...) {
37740       {
37741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37742       };
37743     }
37744   }
37745
37746 }
37747
37748
37749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37750   void * jresult ;
37751   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37752   Dali::ClippingBox result;
37753
37754   arg1 = (Dali::Layer *)jarg1;
37755   {
37756     try {
37757       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
37758     } catch (std::out_of_range& e) {
37759       {
37760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37761       };
37762     } catch (std::exception& e) {
37763       {
37764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37765       };
37766     } catch (Dali::DaliException e) {
37767       {
37768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37769       };
37770     } catch (...) {
37771       {
37772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37773       };
37774     }
37775   }
37776
37777   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37778   return jresult;
37779 }
37780
37781
37782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37783   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37784   bool arg2 ;
37785
37786   arg1 = (Dali::Layer *)jarg1;
37787   arg2 = jarg2 ? true : false;
37788   {
37789     try {
37790       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
37791     } catch (std::out_of_range& e) {
37792       {
37793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37794       };
37795     } catch (std::exception& e) {
37796       {
37797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37798       };
37799     } catch (Dali::DaliException e) {
37800       {
37801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37802       };
37803     } catch (...) {
37804       {
37805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37806       };
37807     }
37808   }
37809
37810 }
37811
37812
37813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37814   unsigned int jresult ;
37815   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37816   bool result;
37817
37818   arg1 = (Dali::Layer *)jarg1;
37819   {
37820     try {
37821       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
37822     } catch (std::out_of_range& e) {
37823       {
37824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37825       };
37826     } catch (std::exception& e) {
37827       {
37828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37829       };
37830     } catch (Dali::DaliException e) {
37831       {
37832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37833       };
37834     } catch (...) {
37835       {
37836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37837       };
37838     }
37839   }
37840
37841   jresult = result;
37842   return jresult;
37843 }
37844
37845
37846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
37847   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37848   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
37849
37850   arg1 = (Dali::Layer *)jarg1;
37851   arg2 = (Dali::Layer::SortFunctionType)jarg2;
37852   {
37853     try {
37854       (arg1)->SetSortFunction(arg2);
37855     } catch (std::out_of_range& e) {
37856       {
37857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37858       };
37859     } catch (std::exception& e) {
37860       {
37861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37862       };
37863     } catch (Dali::DaliException e) {
37864       {
37865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37866       };
37867     } catch (...) {
37868       {
37869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37870       };
37871     }
37872   }
37873
37874 }
37875
37876
37877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
37878   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37879   bool arg2 ;
37880
37881   arg1 = (Dali::Layer *)jarg1;
37882   arg2 = jarg2 ? true : false;
37883   {
37884     try {
37885       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
37886     } catch (std::out_of_range& e) {
37887       {
37888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37889       };
37890     } catch (std::exception& e) {
37891       {
37892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37893       };
37894     } catch (Dali::DaliException e) {
37895       {
37896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37897       };
37898     } catch (...) {
37899       {
37900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37901       };
37902     }
37903   }
37904
37905 }
37906
37907
37908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
37909   unsigned int jresult ;
37910   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37911   bool result;
37912
37913   arg1 = (Dali::Layer *)jarg1;
37914   {
37915     try {
37916       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
37917     } catch (std::out_of_range& e) {
37918       {
37919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37920       };
37921     } catch (std::exception& e) {
37922       {
37923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37924       };
37925     } catch (Dali::DaliException e) {
37926       {
37927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37928       };
37929     } catch (...) {
37930       {
37931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37932       };
37933     }
37934   }
37935
37936   jresult = result;
37937   return jresult;
37938 }
37939
37940
37941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
37942   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37943   bool arg2 ;
37944
37945   arg1 = (Dali::Layer *)jarg1;
37946   arg2 = jarg2 ? true : false;
37947   {
37948     try {
37949       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
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 unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
37973   unsigned int jresult ;
37974   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37975   bool result;
37976
37977   arg1 = (Dali::Layer *)jarg1;
37978   {
37979     try {
37980       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
37981     } catch (std::out_of_range& e) {
37982       {
37983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37984       };
37985     } catch (std::exception& e) {
37986       {
37987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37988       };
37989     } catch (Dali::DaliException e) {
37990       {
37991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37992       };
37993     } catch (...) {
37994       {
37995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37996       };
37997     }
37998   }
37999
38000   jresult = result;
38001   return jresult;
38002 }
38003
38004
38005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38006   void * jresult ;
38007   Dali::Vector4 *result = 0 ;
38008
38009   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38010   jresult = (void *)result;
38011   return jresult;
38012 }
38013
38014
38015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38016   void * jresult ;
38017   Dali::Vector4 *result = 0 ;
38018
38019   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38020   jresult = (void *)result;
38021   return jresult;
38022 }
38023
38024
38025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38026   void * jresult ;
38027   Dali::Stage *result = 0 ;
38028
38029   {
38030     try {
38031       result = (Dali::Stage *)new Dali::Stage();
38032     } catch (std::out_of_range& e) {
38033       {
38034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38035       };
38036     } catch (std::exception& e) {
38037       {
38038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38039       };
38040     } catch (Dali::DaliException e) {
38041       {
38042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38043       };
38044     } catch (...) {
38045       {
38046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38047       };
38048     }
38049   }
38050
38051   jresult = (void *)result;
38052   return jresult;
38053 }
38054
38055
38056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38057   void * jresult ;
38058   Dali::Stage result;
38059
38060   {
38061     try {
38062       result = Dali::Stage::GetCurrent();
38063     } catch (std::out_of_range& e) {
38064       {
38065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38066       };
38067     } catch (std::exception& e) {
38068       {
38069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38070       };
38071     } catch (Dali::DaliException e) {
38072       {
38073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38074       };
38075     } catch (...) {
38076       {
38077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38078       };
38079     }
38080   }
38081
38082   jresult = new Dali::Stage((const Dali::Stage &)result);
38083   return jresult;
38084 }
38085
38086
38087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38088   unsigned int jresult ;
38089   bool result;
38090
38091   {
38092     try {
38093       result = (bool)Dali::Stage::IsInstalled();
38094     } catch (std::out_of_range& e) {
38095       {
38096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38097       };
38098     } catch (std::exception& e) {
38099       {
38100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38101       };
38102     } catch (Dali::DaliException e) {
38103       {
38104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38105       };
38106     } catch (...) {
38107       {
38108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38109       };
38110     }
38111   }
38112
38113   jresult = result;
38114   return jresult;
38115 }
38116
38117
38118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38119   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38120
38121   arg1 = (Dali::Stage *)jarg1;
38122   {
38123     try {
38124       delete arg1;
38125     } catch (std::out_of_range& e) {
38126       {
38127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38128       };
38129     } catch (std::exception& e) {
38130       {
38131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38132       };
38133     } catch (Dali::DaliException e) {
38134       {
38135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38136       };
38137     } catch (...) {
38138       {
38139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38140       };
38141     }
38142   }
38143
38144 }
38145
38146
38147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38148   void * jresult ;
38149   Dali::Stage *arg1 = 0 ;
38150   Dali::Stage *result = 0 ;
38151
38152   arg1 = (Dali::Stage *)jarg1;
38153   if (!arg1) {
38154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38155     return 0;
38156   }
38157   {
38158     try {
38159       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38160     } catch (std::out_of_range& e) {
38161       {
38162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38163       };
38164     } catch (std::exception& e) {
38165       {
38166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38167       };
38168     } catch (Dali::DaliException e) {
38169       {
38170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38171       };
38172     } catch (...) {
38173       {
38174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38175       };
38176     }
38177   }
38178
38179   jresult = (void *)result;
38180   return jresult;
38181 }
38182
38183
38184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38185   void * jresult ;
38186   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38187   Dali::Stage *arg2 = 0 ;
38188   Dali::Stage *result = 0 ;
38189
38190   arg1 = (Dali::Stage *)jarg1;
38191   arg2 = (Dali::Stage *)jarg2;
38192   if (!arg2) {
38193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38194     return 0;
38195   }
38196   {
38197     try {
38198       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38199     } catch (std::out_of_range& e) {
38200       {
38201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38202       };
38203     } catch (std::exception& e) {
38204       {
38205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38206       };
38207     } catch (Dali::DaliException e) {
38208       {
38209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38210       };
38211     } catch (...) {
38212       {
38213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38214       };
38215     }
38216   }
38217
38218   jresult = (void *)result;
38219   return jresult;
38220 }
38221
38222
38223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38224   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38225   Dali::Actor *arg2 = 0 ;
38226
38227   arg1 = (Dali::Stage *)jarg1;
38228   arg2 = (Dali::Actor *)jarg2;
38229   if (!arg2) {
38230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38231     return ;
38232   }
38233   {
38234     try {
38235       (arg1)->Add(*arg2);
38236     } catch (std::out_of_range& e) {
38237       {
38238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38239       };
38240     } catch (std::exception& e) {
38241       {
38242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38243       };
38244     } catch (Dali::DaliException e) {
38245       {
38246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38247       };
38248     } catch (...) {
38249       {
38250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38251       };
38252     }
38253   }
38254
38255 }
38256
38257
38258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38259   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38260   Dali::Actor *arg2 = 0 ;
38261
38262   arg1 = (Dali::Stage *)jarg1;
38263   arg2 = (Dali::Actor *)jarg2;
38264   if (!arg2) {
38265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38266     return ;
38267   }
38268   {
38269     try {
38270       (arg1)->Remove(*arg2);
38271     } catch (std::out_of_range& e) {
38272       {
38273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38274       };
38275     } catch (std::exception& e) {
38276       {
38277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38278       };
38279     } catch (Dali::DaliException e) {
38280       {
38281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38282       };
38283     } catch (...) {
38284       {
38285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38286       };
38287     }
38288   }
38289
38290 }
38291
38292
38293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38294   void * jresult ;
38295   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38296   Dali::Vector2 result;
38297
38298   arg1 = (Dali::Stage *)jarg1;
38299   {
38300     try {
38301       result = ((Dali::Stage const *)arg1)->GetSize();
38302     } catch (std::out_of_range& e) {
38303       {
38304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38305       };
38306     } catch (std::exception& e) {
38307       {
38308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38309       };
38310     } catch (Dali::DaliException e) {
38311       {
38312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38313       };
38314     } catch (...) {
38315       {
38316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38317       };
38318     }
38319   }
38320
38321   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38322   return jresult;
38323 }
38324
38325
38326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38327   void * jresult ;
38328   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38329   Dali::RenderTaskList result;
38330
38331   arg1 = (Dali::Stage *)jarg1;
38332   {
38333     try {
38334       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38335     } catch (std::out_of_range& e) {
38336       {
38337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38338       };
38339     } catch (std::exception& e) {
38340       {
38341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38342       };
38343     } catch (Dali::DaliException e) {
38344       {
38345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38346       };
38347     } catch (...) {
38348       {
38349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38350       };
38351     }
38352   }
38353
38354   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38355   return jresult;
38356 }
38357
38358
38359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38360   unsigned int jresult ;
38361   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38362   unsigned int result;
38363
38364   arg1 = (Dali::Stage *)jarg1;
38365   {
38366     try {
38367       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38368     } catch (std::out_of_range& e) {
38369       {
38370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38371       };
38372     } catch (std::exception& e) {
38373       {
38374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38375       };
38376     } catch (Dali::DaliException e) {
38377       {
38378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38379       };
38380     } catch (...) {
38381       {
38382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38383       };
38384     }
38385   }
38386
38387   jresult = result;
38388   return jresult;
38389 }
38390
38391
38392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38393   void * jresult ;
38394   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38395   unsigned int arg2 ;
38396   Dali::Layer result;
38397
38398   arg1 = (Dali::Stage *)jarg1;
38399   arg2 = (unsigned int)jarg2;
38400   {
38401     try {
38402       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38403     } catch (std::out_of_range& e) {
38404       {
38405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38406       };
38407     } catch (std::exception& e) {
38408       {
38409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38410       };
38411     } catch (Dali::DaliException e) {
38412       {
38413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38414       };
38415     } catch (...) {
38416       {
38417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38418       };
38419     }
38420   }
38421
38422   jresult = new Dali::Layer((const Dali::Layer &)result);
38423   return jresult;
38424 }
38425
38426
38427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38428   void * jresult ;
38429   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38430   Dali::Layer result;
38431
38432   arg1 = (Dali::Stage *)jarg1;
38433   {
38434     try {
38435       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38436     } catch (std::out_of_range& e) {
38437       {
38438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38439       };
38440     } catch (std::exception& e) {
38441       {
38442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38443       };
38444     } catch (Dali::DaliException e) {
38445       {
38446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38447       };
38448     } catch (...) {
38449       {
38450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38451       };
38452     }
38453   }
38454
38455   jresult = new Dali::Layer((const Dali::Layer &)result);
38456   return jresult;
38457 }
38458
38459
38460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38461   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38462   Dali::Vector4 arg2 ;
38463   Dali::Vector4 *argp2 ;
38464
38465   arg1 = (Dali::Stage *)jarg1;
38466   argp2 = (Dali::Vector4 *)jarg2;
38467   if (!argp2) {
38468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38469     return ;
38470   }
38471   arg2 = *argp2;
38472   {
38473     try {
38474       (arg1)->SetBackgroundColor(arg2);
38475     } catch (std::out_of_range& e) {
38476       {
38477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38478       };
38479     } catch (std::exception& e) {
38480       {
38481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38482       };
38483     } catch (Dali::DaliException e) {
38484       {
38485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38486       };
38487     } catch (...) {
38488       {
38489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38490       };
38491     }
38492   }
38493
38494 }
38495
38496
38497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38498   void * jresult ;
38499   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38500   Dali::Vector4 result;
38501
38502   arg1 = (Dali::Stage *)jarg1;
38503   {
38504     try {
38505       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38506     } catch (std::out_of_range& e) {
38507       {
38508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38509       };
38510     } catch (std::exception& e) {
38511       {
38512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38513       };
38514     } catch (Dali::DaliException e) {
38515       {
38516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38517       };
38518     } catch (...) {
38519       {
38520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38521       };
38522     }
38523   }
38524
38525   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38526   return jresult;
38527 }
38528
38529
38530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38531   void * jresult ;
38532   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38533   Dali::Vector2 result;
38534
38535   arg1 = (Dali::Stage *)jarg1;
38536   {
38537     try {
38538       result = ((Dali::Stage const *)arg1)->GetDpi();
38539     } catch (std::out_of_range& e) {
38540       {
38541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38542       };
38543     } catch (std::exception& e) {
38544       {
38545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38546       };
38547     } catch (Dali::DaliException e) {
38548       {
38549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38550       };
38551     } catch (...) {
38552       {
38553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38554       };
38555     }
38556   }
38557
38558   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38559   return jresult;
38560 }
38561
38562
38563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38564   void * jresult ;
38565   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38566   Dali::ObjectRegistry result;
38567
38568   arg1 = (Dali::Stage *)jarg1;
38569   {
38570     try {
38571       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38572     } catch (std::out_of_range& e) {
38573       {
38574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38575       };
38576     } catch (std::exception& e) {
38577       {
38578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38579       };
38580     } catch (Dali::DaliException e) {
38581       {
38582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38583       };
38584     } catch (...) {
38585       {
38586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38587       };
38588     }
38589   }
38590
38591   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38592   return jresult;
38593 }
38594
38595
38596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38597   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38598   float arg2 ;
38599
38600   arg1 = (Dali::Stage *)jarg1;
38601   arg2 = (float)jarg2;
38602   {
38603     try {
38604       (arg1)->KeepRendering(arg2);
38605     } catch (std::out_of_range& e) {
38606       {
38607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38608       };
38609     } catch (std::exception& e) {
38610       {
38611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38612       };
38613     } catch (Dali::DaliException e) {
38614       {
38615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38616       };
38617     } catch (...) {
38618       {
38619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38620       };
38621     }
38622   }
38623
38624 }
38625
38626
38627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38628   void * jresult ;
38629   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38630   Dali::Stage::KeyEventSignalType *result = 0 ;
38631
38632   arg1 = (Dali::Stage *)jarg1;
38633   {
38634     try {
38635       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38636     } catch (std::out_of_range& e) {
38637       {
38638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38639       };
38640     } catch (std::exception& e) {
38641       {
38642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38643       };
38644     } catch (Dali::DaliException e) {
38645       {
38646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38647       };
38648     } catch (...) {
38649       {
38650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38651       };
38652     }
38653   }
38654
38655   jresult = (void *)result;
38656   return jresult;
38657 }
38658
38659
38660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38661   void * jresult ;
38662   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38663   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38664
38665   arg1 = (Dali::Stage *)jarg1;
38666   {
38667     try {
38668       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38669     } catch (std::out_of_range& e) {
38670       {
38671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38672       };
38673     } catch (std::exception& e) {
38674       {
38675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38676       };
38677     } catch (Dali::DaliException e) {
38678       {
38679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38680       };
38681     } catch (...) {
38682       {
38683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38684       };
38685     }
38686   }
38687
38688   jresult = (void *)result;
38689   return jresult;
38690 }
38691
38692
38693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38694   void * jresult ;
38695   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38696   Dali::Stage::TouchSignalType *result = 0 ;
38697
38698   arg1 = (Dali::Stage *)jarg1;
38699   {
38700     try {
38701       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38702     } catch (std::out_of_range& e) {
38703       {
38704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38705       };
38706     } catch (std::exception& e) {
38707       {
38708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38709       };
38710     } catch (Dali::DaliException e) {
38711       {
38712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38713       };
38714     } catch (...) {
38715       {
38716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38717       };
38718     }
38719   }
38720
38721   jresult = (void *)result;
38722   return jresult;
38723 }
38724
38725
38726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38727   void * jresult ;
38728   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38729   Dali::Stage::WheelEventSignalType *result = 0 ;
38730
38731   arg1 = (Dali::Stage *)jarg1;
38732   {
38733     try {
38734       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38735     } catch (std::out_of_range& e) {
38736       {
38737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38738       };
38739     } catch (std::exception& e) {
38740       {
38741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38742       };
38743     } catch (Dali::DaliException e) {
38744       {
38745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38746       };
38747     } catch (...) {
38748       {
38749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38750       };
38751     }
38752   }
38753
38754   jresult = (void *)result;
38755   return jresult;
38756 }
38757
38758
38759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38760   void * jresult ;
38761   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38762   Dali::Stage::ContextStatusSignal *result = 0 ;
38763
38764   arg1 = (Dali::Stage *)jarg1;
38765   {
38766     try {
38767       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38768     } catch (std::out_of_range& e) {
38769       {
38770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38771       };
38772     } catch (std::exception& e) {
38773       {
38774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38775       };
38776     } catch (Dali::DaliException e) {
38777       {
38778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38779       };
38780     } catch (...) {
38781       {
38782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38783       };
38784     }
38785   }
38786
38787   jresult = (void *)result;
38788   return jresult;
38789 }
38790
38791
38792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38793   void * jresult ;
38794   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38795   Dali::Stage::ContextStatusSignal *result = 0 ;
38796
38797   arg1 = (Dali::Stage *)jarg1;
38798   {
38799     try {
38800       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38801     } catch (std::out_of_range& e) {
38802       {
38803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38804       };
38805     } catch (std::exception& e) {
38806       {
38807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38808       };
38809     } catch (Dali::DaliException e) {
38810       {
38811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38812       };
38813     } catch (...) {
38814       {
38815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38816       };
38817     }
38818   }
38819
38820   jresult = (void *)result;
38821   return jresult;
38822 }
38823
38824
38825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38826   void * jresult ;
38827   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38828   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38829
38830   arg1 = (Dali::Stage *)jarg1;
38831   {
38832     try {
38833       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38834     } catch (std::out_of_range& e) {
38835       {
38836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38837       };
38838     } catch (std::exception& e) {
38839       {
38840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38841       };
38842     } catch (Dali::DaliException e) {
38843       {
38844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38845       };
38846     } catch (...) {
38847       {
38848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38849       };
38850     }
38851   }
38852
38853   jresult = (void *)result;
38854   return jresult;
38855 }
38856
38857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38858   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38859   Dali::DevelStage::Rendering arg2 ;
38860
38861   arg1 = (Dali::Stage *)jarg1;
38862   arg2 = (Dali::DevelStage::Rendering)jarg2;
38863   {
38864     try {
38865       DevelStage::SetRenderingBehavior(*arg1,arg2);
38866     } catch (std::out_of_range& e) {
38867       {
38868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38869       };
38870     } catch (std::exception& e) {
38871       {
38872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38873       };
38874     } catch (Dali::DaliException e) {
38875       {
38876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38877       };
38878     } catch (...) {
38879       {
38880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38881       };
38882     }
38883   }
38884
38885 }
38886
38887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38888
38889   int jresult ;
38890   int result ;
38891   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38892
38893   arg1 = (Dali::Stage *)jarg1;
38894   {
38895     try {
38896       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38897     } catch (std::out_of_range& e) {
38898       {
38899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38900       };
38901     } catch (std::exception& e) {
38902       {
38903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38904       };
38905     } catch (Dali::DaliException e) {
38906       {
38907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38908       };
38909     } catch (...) {
38910       {
38911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38912       };
38913     }
38914   }
38915
38916   jresult = result;
38917   return jresult;
38918 }
38919
38920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38921   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38922
38923   arg1 = (Dali::RelayoutContainer *)jarg1;
38924   {
38925     try {
38926       delete arg1;
38927     } catch (std::out_of_range& e) {
38928       {
38929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38930       };
38931     } catch (std::exception& e) {
38932       {
38933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38934       };
38935     } catch (Dali::DaliException e) {
38936       {
38937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38938       };
38939     } catch (...) {
38940       {
38941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38942       };
38943     }
38944   }
38945
38946 }
38947
38948
38949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38950   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38951   Dali::Actor *arg2 = 0 ;
38952   Dali::Vector2 *arg3 = 0 ;
38953
38954   arg1 = (Dali::RelayoutContainer *)jarg1;
38955   arg2 = (Dali::Actor *)jarg2;
38956   if (!arg2) {
38957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38958     return ;
38959   }
38960   arg3 = (Dali::Vector2 *)jarg3;
38961   if (!arg3) {
38962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38963     return ;
38964   }
38965   {
38966     try {
38967       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38968     } catch (std::out_of_range& e) {
38969       {
38970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38971       };
38972     } catch (std::exception& e) {
38973       {
38974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38975       };
38976     } catch (Dali::DaliException e) {
38977       {
38978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38979       };
38980     } catch (...) {
38981       {
38982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38983       };
38984     }
38985   }
38986
38987 }
38988
38989
38990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38991   void * jresult ;
38992   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38993   Dali::CustomActor result;
38994
38995   arg1 = (Dali::CustomActorImpl *)jarg1;
38996   {
38997     try {
38998       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38999     } catch (std::out_of_range& e) {
39000       {
39001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39002       };
39003     } catch (std::exception& e) {
39004       {
39005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39006       };
39007     } catch (Dali::DaliException e) {
39008       {
39009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39010       };
39011     } catch (...) {
39012       {
39013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39014       };
39015     }
39016   }
39017
39018   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39019   return jresult;
39020 }
39021
39022
39023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39024   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39025   int arg2 ;
39026
39027   arg1 = (Dali::CustomActorImpl *)jarg1;
39028   arg2 = (int)jarg2;
39029   {
39030     try {
39031       (arg1)->OnStageConnection(arg2);
39032     } catch (std::out_of_range& e) {
39033       {
39034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39035       };
39036     } catch (std::exception& e) {
39037       {
39038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39039       };
39040     } catch (Dali::DaliException e) {
39041       {
39042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39043       };
39044     } catch (...) {
39045       {
39046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39047       };
39048     }
39049   }
39050
39051 }
39052
39053
39054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39055   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39056
39057   arg1 = (Dali::CustomActorImpl *)jarg1;
39058   {
39059     try {
39060       (arg1)->OnStageDisconnection();
39061     } catch (std::out_of_range& e) {
39062       {
39063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39064       };
39065     } catch (std::exception& e) {
39066       {
39067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39068       };
39069     } catch (Dali::DaliException e) {
39070       {
39071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39072       };
39073     } catch (...) {
39074       {
39075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39076       };
39077     }
39078   }
39079
39080 }
39081
39082
39083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39084   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39085   Dali::Actor *arg2 = 0 ;
39086
39087   arg1 = (Dali::CustomActorImpl *)jarg1;
39088   arg2 = (Dali::Actor *)jarg2;
39089   if (!arg2) {
39090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39091     return ;
39092   }
39093   {
39094     try {
39095       (arg1)->OnChildAdd(*arg2);
39096     } catch (std::out_of_range& e) {
39097       {
39098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39099       };
39100     } catch (std::exception& e) {
39101       {
39102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39103       };
39104     } catch (Dali::DaliException e) {
39105       {
39106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39107       };
39108     } catch (...) {
39109       {
39110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39111       };
39112     }
39113   }
39114
39115 }
39116
39117
39118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39119   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39120   Dali::Actor *arg2 = 0 ;
39121
39122   arg1 = (Dali::CustomActorImpl *)jarg1;
39123   arg2 = (Dali::Actor *)jarg2;
39124   if (!arg2) {
39125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39126     return ;
39127   }
39128   {
39129     try {
39130       (arg1)->OnChildRemove(*arg2);
39131     } catch (std::out_of_range& e) {
39132       {
39133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39134       };
39135     } catch (std::exception& e) {
39136       {
39137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39138       };
39139     } catch (Dali::DaliException e) {
39140       {
39141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39142       };
39143     } catch (...) {
39144       {
39145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39146       };
39147     }
39148   }
39149
39150 }
39151
39152
39153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39154   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39155   Dali::Property::Index arg2 ;
39156   Dali::Property::Value arg3 ;
39157   Dali::Property::Value *argp3 ;
39158
39159   arg1 = (Dali::CustomActorImpl *)jarg1;
39160   arg2 = (Dali::Property::Index)jarg2;
39161   argp3 = (Dali::Property::Value *)jarg3;
39162   if (!argp3) {
39163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39164     return ;
39165   }
39166   arg3 = *argp3;
39167   {
39168     try {
39169       (arg1)->OnPropertySet(arg2,arg3);
39170     } catch (std::out_of_range& e) {
39171       {
39172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39173       };
39174     } catch (std::exception& e) {
39175       {
39176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39177       };
39178     } catch (Dali::DaliException e) {
39179       {
39180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39181       };
39182     } catch (...) {
39183       {
39184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39185       };
39186     }
39187   }
39188
39189 }
39190
39191
39192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39193   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39194   Dali::Vector3 *arg2 = 0 ;
39195
39196   arg1 = (Dali::CustomActorImpl *)jarg1;
39197   arg2 = (Dali::Vector3 *)jarg2;
39198   if (!arg2) {
39199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39200     return ;
39201   }
39202   {
39203     try {
39204       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39205     } catch (std::out_of_range& e) {
39206       {
39207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39208       };
39209     } catch (std::exception& e) {
39210       {
39211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39212       };
39213     } catch (Dali::DaliException e) {
39214       {
39215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39216       };
39217     } catch (...) {
39218       {
39219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39220       };
39221     }
39222   }
39223
39224 }
39225
39226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39227   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39228   Dali::Animation *arg2 = 0 ;
39229   Dali::Vector3 *arg3 = 0 ;
39230
39231   arg1 = (Dali::CustomActorImpl *)jarg1;
39232   arg2 = (Dali::Animation *)jarg2;
39233   if (!arg2) {
39234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39235     return ;
39236   }
39237   arg3 = (Dali::Vector3 *)jarg3;
39238   if (!arg3) {
39239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39240     return ;
39241   }
39242   {
39243     try {
39244       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39245     } catch (std::out_of_range& e) {
39246       {
39247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39248       };
39249     } catch (std::exception& e) {
39250       {
39251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39252       };
39253     } catch (Dali::DaliException e) {
39254       {
39255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39256       };
39257     } catch (...) {
39258       {
39259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39260       };
39261     }
39262   }
39263
39264 }
39265
39266
39267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39268   unsigned int jresult ;
39269   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39270   Dali::TouchEvent *arg2 = 0 ;
39271   bool result;
39272
39273   arg1 = (Dali::CustomActorImpl *)jarg1;
39274   arg2 = (Dali::TouchEvent *)jarg2;
39275   if (!arg2) {
39276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39277     return 0;
39278   }
39279   {
39280     try {
39281       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39282     } catch (std::out_of_range& e) {
39283       {
39284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39285       };
39286     } catch (std::exception& e) {
39287       {
39288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39289       };
39290     } catch (Dali::DaliException e) {
39291       {
39292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39293       };
39294     } catch (...) {
39295       {
39296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39297       };
39298     }
39299   }
39300
39301   jresult = result;
39302   return jresult;
39303 }
39304
39305
39306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39307   unsigned int jresult ;
39308   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39309   Dali::HoverEvent *arg2 = 0 ;
39310   bool result;
39311
39312   arg1 = (Dali::CustomActorImpl *)jarg1;
39313   arg2 = (Dali::HoverEvent *)jarg2;
39314   if (!arg2) {
39315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39316     return 0;
39317   }
39318   {
39319     try {
39320       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39321     } catch (std::out_of_range& e) {
39322       {
39323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39324       };
39325     } catch (std::exception& e) {
39326       {
39327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39328       };
39329     } catch (Dali::DaliException e) {
39330       {
39331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39332       };
39333     } catch (...) {
39334       {
39335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39336       };
39337     }
39338   }
39339
39340   jresult = result;
39341   return jresult;
39342 }
39343
39344
39345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39346   unsigned int jresult ;
39347   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39348   Dali::KeyEvent *arg2 = 0 ;
39349   bool result;
39350
39351   arg1 = (Dali::CustomActorImpl *)jarg1;
39352   arg2 = (Dali::KeyEvent *)jarg2;
39353   if (!arg2) {
39354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39355     return 0;
39356   }
39357   {
39358     try {
39359       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39360     } catch (std::out_of_range& e) {
39361       {
39362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39363       };
39364     } catch (std::exception& e) {
39365       {
39366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39367       };
39368     } catch (Dali::DaliException e) {
39369       {
39370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39371       };
39372     } catch (...) {
39373       {
39374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39375       };
39376     }
39377   }
39378
39379   jresult = result;
39380   return jresult;
39381 }
39382
39383
39384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39385   unsigned int jresult ;
39386   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39387   Dali::WheelEvent *arg2 = 0 ;
39388   bool result;
39389
39390   arg1 = (Dali::CustomActorImpl *)jarg1;
39391   arg2 = (Dali::WheelEvent *)jarg2;
39392   if (!arg2) {
39393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39394     return 0;
39395   }
39396   {
39397     try {
39398       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39399     } catch (std::out_of_range& e) {
39400       {
39401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39402       };
39403     } catch (std::exception& e) {
39404       {
39405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39406       };
39407     } catch (Dali::DaliException e) {
39408       {
39409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39410       };
39411     } catch (...) {
39412       {
39413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39414       };
39415     }
39416   }
39417
39418   jresult = result;
39419   return jresult;
39420 }
39421
39422
39423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39424   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39425   Dali::Vector2 *arg2 = 0 ;
39426   Dali::RelayoutContainer *arg3 = 0 ;
39427
39428   arg1 = (Dali::CustomActorImpl *)jarg1;
39429   arg2 = (Dali::Vector2 *)jarg2;
39430   if (!arg2) {
39431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39432     return ;
39433   }
39434   arg3 = (Dali::RelayoutContainer *)jarg3;
39435   if (!arg3) {
39436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39437     return ;
39438   }
39439   {
39440     try {
39441       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39442     } catch (std::out_of_range& e) {
39443       {
39444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39445       };
39446     } catch (std::exception& e) {
39447       {
39448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39449       };
39450     } catch (Dali::DaliException e) {
39451       {
39452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39453       };
39454     } catch (...) {
39455       {
39456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39457       };
39458     }
39459   }
39460
39461 }
39462
39463
39464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39465   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39466   Dali::ResizePolicy::Type arg2 ;
39467   Dali::Dimension::Type arg3 ;
39468
39469   arg1 = (Dali::CustomActorImpl *)jarg1;
39470   arg2 = (Dali::ResizePolicy::Type)jarg2;
39471   arg3 = (Dali::Dimension::Type)jarg3;
39472   {
39473     try {
39474       (arg1)->OnSetResizePolicy(arg2,arg3);
39475     } catch (std::out_of_range& e) {
39476       {
39477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39478       };
39479     } catch (std::exception& e) {
39480       {
39481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39482       };
39483     } catch (Dali::DaliException e) {
39484       {
39485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39486       };
39487     } catch (...) {
39488       {
39489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39490       };
39491     }
39492   }
39493
39494 }
39495
39496
39497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39498   void * jresult ;
39499   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39500   Dali::Vector3 result;
39501
39502   arg1 = (Dali::CustomActorImpl *)jarg1;
39503   {
39504     try {
39505       result = (arg1)->GetNaturalSize();
39506     } catch (std::out_of_range& e) {
39507       {
39508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39509       };
39510     } catch (std::exception& e) {
39511       {
39512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39513       };
39514     } catch (Dali::DaliException e) {
39515       {
39516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39517       };
39518     } catch (...) {
39519       {
39520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39521       };
39522     }
39523   }
39524
39525   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39526   return jresult;
39527 }
39528
39529
39530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39531   float jresult ;
39532   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39533   Dali::Actor *arg2 = 0 ;
39534   Dali::Dimension::Type arg3 ;
39535   float result;
39536
39537   arg1 = (Dali::CustomActorImpl *)jarg1;
39538   arg2 = (Dali::Actor *)jarg2;
39539   if (!arg2) {
39540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39541     return 0;
39542   }
39543   arg3 = (Dali::Dimension::Type)jarg3;
39544   {
39545     try {
39546       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39547     } catch (std::out_of_range& e) {
39548       {
39549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39550       };
39551     } catch (std::exception& e) {
39552       {
39553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39554       };
39555     } catch (Dali::DaliException e) {
39556       {
39557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39558       };
39559     } catch (...) {
39560       {
39561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39562       };
39563     }
39564   }
39565
39566   jresult = result;
39567   return jresult;
39568 }
39569
39570
39571 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39572   float jresult ;
39573   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39574   float arg2 ;
39575   float result;
39576
39577   arg1 = (Dali::CustomActorImpl *)jarg1;
39578   arg2 = (float)jarg2;
39579   {
39580     try {
39581       result = (float)(arg1)->GetHeightForWidth(arg2);
39582     } catch (std::out_of_range& e) {
39583       {
39584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39585       };
39586     } catch (std::exception& e) {
39587       {
39588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39589       };
39590     } catch (Dali::DaliException e) {
39591       {
39592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39593       };
39594     } catch (...) {
39595       {
39596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39597       };
39598     }
39599   }
39600
39601   jresult = result;
39602   return jresult;
39603 }
39604
39605
39606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39607   float jresult ;
39608   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39609   float arg2 ;
39610   float result;
39611
39612   arg1 = (Dali::CustomActorImpl *)jarg1;
39613   arg2 = (float)jarg2;
39614   {
39615     try {
39616       result = (float)(arg1)->GetWidthForHeight(arg2);
39617     } catch (std::out_of_range& e) {
39618       {
39619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39620       };
39621     } catch (std::exception& e) {
39622       {
39623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39624       };
39625     } catch (Dali::DaliException e) {
39626       {
39627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39628       };
39629     } catch (...) {
39630       {
39631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39632       };
39633     }
39634   }
39635
39636   jresult = result;
39637   return jresult;
39638 }
39639
39640
39641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39642   unsigned int jresult ;
39643   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39644   Dali::Dimension::Type arg2 ;
39645   bool result;
39646
39647   arg1 = (Dali::CustomActorImpl *)jarg1;
39648   arg2 = (Dali::Dimension::Type)jarg2;
39649   {
39650     try {
39651       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39652     } catch (std::out_of_range& e) {
39653       {
39654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39655       };
39656     } catch (std::exception& e) {
39657       {
39658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39659       };
39660     } catch (Dali::DaliException e) {
39661       {
39662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39663       };
39664     } catch (...) {
39665       {
39666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39667       };
39668     }
39669   }
39670
39671   jresult = result;
39672   return jresult;
39673 }
39674
39675
39676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39677   unsigned int jresult ;
39678   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39679   bool result;
39680
39681   arg1 = (Dali::CustomActorImpl *)jarg1;
39682   {
39683     try {
39684       result = (bool)(arg1)->RelayoutDependentOnChildren();
39685     } catch (std::out_of_range& e) {
39686       {
39687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39688       };
39689     } catch (std::exception& e) {
39690       {
39691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39692       };
39693     } catch (Dali::DaliException e) {
39694       {
39695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39696       };
39697     } catch (...) {
39698       {
39699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39700       };
39701     }
39702   }
39703
39704   jresult = result;
39705   return jresult;
39706 }
39707
39708
39709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39710   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39711   Dali::Dimension::Type arg2 ;
39712
39713   arg1 = (Dali::CustomActorImpl *)jarg1;
39714   arg2 = (Dali::Dimension::Type)jarg2;
39715   {
39716     try {
39717       (arg1)->OnCalculateRelayoutSize(arg2);
39718     } catch (std::out_of_range& e) {
39719       {
39720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39721       };
39722     } catch (std::exception& e) {
39723       {
39724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39725       };
39726     } catch (Dali::DaliException e) {
39727       {
39728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39729       };
39730     } catch (...) {
39731       {
39732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39733       };
39734     }
39735   }
39736
39737 }
39738
39739
39740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39741   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39742   float arg2 ;
39743   Dali::Dimension::Type arg3 ;
39744
39745   arg1 = (Dali::CustomActorImpl *)jarg1;
39746   arg2 = (float)jarg2;
39747   arg3 = (Dali::Dimension::Type)jarg3;
39748   {
39749     try {
39750       (arg1)->OnLayoutNegotiated(arg2,arg3);
39751     } catch (std::out_of_range& e) {
39752       {
39753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39754       };
39755     } catch (std::exception& e) {
39756       {
39757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39758       };
39759     } catch (Dali::DaliException e) {
39760       {
39761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39762       };
39763     } catch (...) {
39764       {
39765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39766       };
39767     }
39768   }
39769
39770 }
39771
39772
39773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39774   unsigned int jresult ;
39775   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39776   bool result;
39777
39778   arg1 = (Dali::CustomActorImpl *)jarg1;
39779   {
39780     try {
39781       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39782     } catch (std::out_of_range& e) {
39783       {
39784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39785       };
39786     } catch (std::exception& e) {
39787       {
39788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39789       };
39790     } catch (Dali::DaliException e) {
39791       {
39792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39793       };
39794     } catch (...) {
39795       {
39796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39797       };
39798     }
39799   }
39800
39801   jresult = result;
39802   return jresult;
39803 }
39804
39805
39806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39807   unsigned int jresult ;
39808   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39809   bool result;
39810
39811   arg1 = (Dali::CustomActorImpl *)jarg1;
39812   {
39813     try {
39814       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39815     } catch (std::out_of_range& e) {
39816       {
39817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39818       };
39819     } catch (std::exception& e) {
39820       {
39821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39822       };
39823     } catch (Dali::DaliException e) {
39824       {
39825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39826       };
39827     } catch (...) {
39828       {
39829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39830       };
39831     }
39832   }
39833
39834   jresult = result;
39835   return jresult;
39836 }
39837
39838
39839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39840   unsigned int jresult ;
39841   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39842   bool result;
39843
39844   arg1 = (Dali::CustomActorImpl *)jarg1;
39845   {
39846     try {
39847       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39848     } catch (std::out_of_range& e) {
39849       {
39850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39851       };
39852     } catch (std::exception& e) {
39853       {
39854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39855       };
39856     } catch (Dali::DaliException e) {
39857       {
39858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39859       };
39860     } catch (...) {
39861       {
39862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39863       };
39864     }
39865   }
39866
39867   jresult = result;
39868   return jresult;
39869 }
39870
39871
39872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39873   unsigned int jresult ;
39874   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39875   bool result;
39876
39877   arg1 = (Dali::CustomActorImpl *)jarg1;
39878   {
39879     try {
39880       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39881     } catch (std::out_of_range& e) {
39882       {
39883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39884       };
39885     } catch (std::exception& e) {
39886       {
39887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39888       };
39889     } catch (Dali::DaliException e) {
39890       {
39891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39892       };
39893     } catch (...) {
39894       {
39895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39896       };
39897     }
39898   }
39899
39900   jresult = result;
39901   return jresult;
39902 }
39903
39904
39905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39906   void * jresult ;
39907   Dali::CustomActor *result = 0 ;
39908
39909   {
39910     try {
39911       result = (Dali::CustomActor *)new Dali::CustomActor();
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 = (void *)result;
39932   return jresult;
39933 }
39934
39935
39936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39937   void * jresult ;
39938   Dali::BaseHandle arg1 ;
39939   Dali::BaseHandle *argp1 ;
39940   Dali::CustomActor result;
39941
39942   argp1 = (Dali::BaseHandle *)jarg1;
39943   if (!argp1) {
39944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39945     return 0;
39946   }
39947   arg1 = *argp1;
39948   {
39949     try {
39950       result = Dali::CustomActor::DownCast(arg1);
39951     } catch (std::out_of_range& e) {
39952       {
39953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39954       };
39955     } catch (std::exception& e) {
39956       {
39957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39958       };
39959     } catch (Dali::DaliException e) {
39960       {
39961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39962       };
39963     } catch (...) {
39964       {
39965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39966       };
39967     }
39968   }
39969
39970   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39971   return jresult;
39972 }
39973
39974
39975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39976   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39977
39978   arg1 = (Dali::CustomActor *)jarg1;
39979   {
39980     try {
39981       delete arg1;
39982     } catch (std::out_of_range& e) {
39983       {
39984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39985       };
39986     } catch (std::exception& e) {
39987       {
39988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39989       };
39990     } catch (Dali::DaliException e) {
39991       {
39992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39993       };
39994     } catch (...) {
39995       {
39996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39997       };
39998     }
39999   }
40000
40001 }
40002
40003
40004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40005   void * jresult ;
40006   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40007   Dali::CustomActorImpl *result = 0 ;
40008
40009   arg1 = (Dali::CustomActor *)jarg1;
40010   {
40011     try {
40012       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40013     } catch (std::out_of_range& e) {
40014       {
40015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40016       };
40017     } catch (std::exception& e) {
40018       {
40019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40020       };
40021     } catch (Dali::DaliException e) {
40022       {
40023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40024       };
40025     } catch (...) {
40026       {
40027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40028       };
40029     }
40030   }
40031
40032   jresult = (void *)result;
40033   return jresult;
40034 }
40035
40036
40037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40038   void * jresult ;
40039   Dali::CustomActorImpl *arg1 = 0 ;
40040   Dali::CustomActor *result = 0 ;
40041
40042   arg1 = (Dali::CustomActorImpl *)jarg1;
40043   if (!arg1) {
40044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40045     return 0;
40046   }
40047   {
40048     try {
40049       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40050     } catch (std::out_of_range& e) {
40051       {
40052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40053       };
40054     } catch (std::exception& e) {
40055       {
40056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40057       };
40058     } catch (Dali::DaliException e) {
40059       {
40060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40061       };
40062     } catch (...) {
40063       {
40064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40065       };
40066     }
40067   }
40068
40069   jresult = (void *)result;
40070   return jresult;
40071 }
40072
40073
40074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40075   void * jresult ;
40076   Dali::CustomActor *arg1 = 0 ;
40077   Dali::CustomActor *result = 0 ;
40078
40079   arg1 = (Dali::CustomActor *)jarg1;
40080   if (!arg1) {
40081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40082     return 0;
40083   }
40084   {
40085     try {
40086       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40087     } catch (std::out_of_range& e) {
40088       {
40089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40090       };
40091     } catch (std::exception& e) {
40092       {
40093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40094       };
40095     } catch (Dali::DaliException e) {
40096       {
40097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40098       };
40099     } catch (...) {
40100       {
40101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40102       };
40103     }
40104   }
40105
40106   jresult = (void *)result;
40107   return jresult;
40108 }
40109
40110
40111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40112   void * jresult ;
40113   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40114   Dali::CustomActor *arg2 = 0 ;
40115   Dali::CustomActor *result = 0 ;
40116
40117   arg1 = (Dali::CustomActor *)jarg1;
40118   arg2 = (Dali::CustomActor *)jarg2;
40119   if (!arg2) {
40120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40121     return 0;
40122   }
40123   {
40124     try {
40125       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40126     } catch (std::out_of_range& e) {
40127       {
40128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40129       };
40130     } catch (std::exception& e) {
40131       {
40132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40133       };
40134     } catch (Dali::DaliException e) {
40135       {
40136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40137       };
40138     } catch (...) {
40139       {
40140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40141       };
40142     }
40143   }
40144
40145   jresult = (void *)result;
40146   return jresult;
40147 }
40148
40149
40150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40151   int jresult ;
40152   int result;
40153
40154   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40155   jresult = (int)result;
40156   return jresult;
40157 }
40158
40159
40160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40161   int jresult ;
40162   int result;
40163
40164   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40165   jresult = (int)result;
40166   return jresult;
40167 }
40168
40169
40170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40171   int jresult ;
40172   int result;
40173
40174   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40175   jresult = (int)result;
40176   return jresult;
40177 }
40178
40179
40180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40181   int jresult ;
40182   int result;
40183
40184   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40185   jresult = (int)result;
40186   return jresult;
40187 }
40188
40189
40190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40191   int jresult ;
40192   int result;
40193
40194   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40195   jresult = (int)result;
40196   return jresult;
40197 }
40198
40199
40200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40201   int jresult ;
40202   int result;
40203
40204   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40205   jresult = (int)result;
40206   return jresult;
40207 }
40208
40209
40210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40211   int jresult ;
40212   int result;
40213
40214   result = (int)Dali::PanGestureDetector::Property::PANNING;
40215   jresult = (int)result;
40216   return jresult;
40217 }
40218
40219
40220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40221   void * jresult ;
40222   Dali::PanGestureDetector::Property *result = 0 ;
40223
40224   {
40225     try {
40226       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40227     } catch (std::out_of_range& e) {
40228       {
40229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40230       };
40231     } catch (std::exception& e) {
40232       {
40233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40234       };
40235     } catch (Dali::DaliException e) {
40236       {
40237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40238       };
40239     } catch (...) {
40240       {
40241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40242       };
40243     }
40244   }
40245
40246   jresult = (void *)result;
40247   return jresult;
40248 }
40249
40250
40251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40252   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40253
40254   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40255   {
40256     try {
40257       delete arg1;
40258     } catch (std::out_of_range& e) {
40259       {
40260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40261       };
40262     } catch (std::exception& e) {
40263       {
40264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40265       };
40266     } catch (Dali::DaliException e) {
40267       {
40268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40269       };
40270     } catch (...) {
40271       {
40272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40273       };
40274     }
40275   }
40276
40277 }
40278
40279
40280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40281   void * jresult ;
40282   Dali::Radian *result = 0 ;
40283
40284   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40285   jresult = (void *)result;
40286   return jresult;
40287 }
40288
40289
40290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40291   void * jresult ;
40292   Dali::Radian *result = 0 ;
40293
40294   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40295   jresult = (void *)result;
40296   return jresult;
40297 }
40298
40299
40300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40301   void * jresult ;
40302   Dali::Radian *result = 0 ;
40303
40304   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40305   jresult = (void *)result;
40306   return jresult;
40307 }
40308
40309
40310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40311   void * jresult ;
40312   Dali::Radian *result = 0 ;
40313
40314   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40315   jresult = (void *)result;
40316   return jresult;
40317 }
40318
40319
40320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40321   void * jresult ;
40322   Dali::Radian *result = 0 ;
40323
40324   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40325   jresult = (void *)result;
40326   return jresult;
40327 }
40328
40329
40330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40331   void * jresult ;
40332   Dali::Radian *result = 0 ;
40333
40334   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40335   jresult = (void *)result;
40336   return jresult;
40337 }
40338
40339
40340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40341   void * jresult ;
40342   Dali::Radian *result = 0 ;
40343
40344   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40345   jresult = (void *)result;
40346   return jresult;
40347 }
40348
40349
40350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40351   void * jresult ;
40352   Dali::PanGestureDetector *result = 0 ;
40353
40354   {
40355     try {
40356       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40357     } catch (std::out_of_range& e) {
40358       {
40359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40360       };
40361     } catch (std::exception& e) {
40362       {
40363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40364       };
40365     } catch (Dali::DaliException e) {
40366       {
40367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40368       };
40369     } catch (...) {
40370       {
40371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40372       };
40373     }
40374   }
40375
40376   jresult = (void *)result;
40377   return jresult;
40378 }
40379
40380
40381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40382   void * jresult ;
40383   Dali::PanGestureDetector result;
40384
40385   {
40386     try {
40387       result = Dali::PanGestureDetector::New();
40388     } catch (std::out_of_range& e) {
40389       {
40390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40391       };
40392     } catch (std::exception& e) {
40393       {
40394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40395       };
40396     } catch (Dali::DaliException e) {
40397       {
40398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40399       };
40400     } catch (...) {
40401       {
40402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40403       };
40404     }
40405   }
40406
40407   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40408   return jresult;
40409 }
40410
40411
40412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40413   void * jresult ;
40414   Dali::BaseHandle arg1 ;
40415   Dali::BaseHandle *argp1 ;
40416   Dali::PanGestureDetector result;
40417
40418   argp1 = (Dali::BaseHandle *)jarg1;
40419   if (!argp1) {
40420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40421     return 0;
40422   }
40423   arg1 = *argp1;
40424   {
40425     try {
40426       result = Dali::PanGestureDetector::DownCast(arg1);
40427     } catch (std::out_of_range& e) {
40428       {
40429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40430       };
40431     } catch (std::exception& e) {
40432       {
40433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40434       };
40435     } catch (Dali::DaliException e) {
40436       {
40437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40438       };
40439     } catch (...) {
40440       {
40441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40442       };
40443     }
40444   }
40445
40446   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40447   return jresult;
40448 }
40449
40450
40451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40452   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40453
40454   arg1 = (Dali::PanGestureDetector *)jarg1;
40455   {
40456     try {
40457       delete arg1;
40458     } catch (std::out_of_range& e) {
40459       {
40460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40461       };
40462     } catch (std::exception& e) {
40463       {
40464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40465       };
40466     } catch (Dali::DaliException e) {
40467       {
40468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40469       };
40470     } catch (...) {
40471       {
40472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40473       };
40474     }
40475   }
40476
40477 }
40478
40479
40480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40481   void * jresult ;
40482   Dali::PanGestureDetector *arg1 = 0 ;
40483   Dali::PanGestureDetector *result = 0 ;
40484
40485   arg1 = (Dali::PanGestureDetector *)jarg1;
40486   if (!arg1) {
40487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40488     return 0;
40489   }
40490   {
40491     try {
40492       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40493     } catch (std::out_of_range& e) {
40494       {
40495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40496       };
40497     } catch (std::exception& e) {
40498       {
40499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40500       };
40501     } catch (Dali::DaliException e) {
40502       {
40503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40504       };
40505     } catch (...) {
40506       {
40507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40508       };
40509     }
40510   }
40511
40512   jresult = (void *)result;
40513   return jresult;
40514 }
40515
40516
40517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40518   void * jresult ;
40519   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40520   Dali::PanGestureDetector *arg2 = 0 ;
40521   Dali::PanGestureDetector *result = 0 ;
40522
40523   arg1 = (Dali::PanGestureDetector *)jarg1;
40524   arg2 = (Dali::PanGestureDetector *)jarg2;
40525   if (!arg2) {
40526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40527     return 0;
40528   }
40529   {
40530     try {
40531       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40532     } catch (std::out_of_range& e) {
40533       {
40534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40535       };
40536     } catch (std::exception& e) {
40537       {
40538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40539       };
40540     } catch (Dali::DaliException e) {
40541       {
40542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40543       };
40544     } catch (...) {
40545       {
40546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40547       };
40548     }
40549   }
40550
40551   jresult = (void *)result;
40552   return jresult;
40553 }
40554
40555
40556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40557   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40558   unsigned int arg2 ;
40559
40560   arg1 = (Dali::PanGestureDetector *)jarg1;
40561   arg2 = (unsigned int)jarg2;
40562   {
40563     try {
40564       (arg1)->SetMinimumTouchesRequired(arg2);
40565     } catch (std::out_of_range& e) {
40566       {
40567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40568       };
40569     } catch (std::exception& e) {
40570       {
40571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40572       };
40573     } catch (Dali::DaliException e) {
40574       {
40575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40576       };
40577     } catch (...) {
40578       {
40579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40580       };
40581     }
40582   }
40583
40584 }
40585
40586
40587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40588   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40589   unsigned int arg2 ;
40590
40591   arg1 = (Dali::PanGestureDetector *)jarg1;
40592   arg2 = (unsigned int)jarg2;
40593   {
40594     try {
40595       (arg1)->SetMaximumTouchesRequired(arg2);
40596     } catch (std::out_of_range& e) {
40597       {
40598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40599       };
40600     } catch (std::exception& e) {
40601       {
40602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40603       };
40604     } catch (Dali::DaliException e) {
40605       {
40606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40607       };
40608     } catch (...) {
40609       {
40610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40611       };
40612     }
40613   }
40614
40615 }
40616
40617
40618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40619   unsigned int jresult ;
40620   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40621   unsigned int result;
40622
40623   arg1 = (Dali::PanGestureDetector *)jarg1;
40624   {
40625     try {
40626       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40627     } catch (std::out_of_range& e) {
40628       {
40629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40630       };
40631     } catch (std::exception& e) {
40632       {
40633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40634       };
40635     } catch (Dali::DaliException e) {
40636       {
40637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40638       };
40639     } catch (...) {
40640       {
40641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40642       };
40643     }
40644   }
40645
40646   jresult = result;
40647   return jresult;
40648 }
40649
40650
40651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40652   unsigned int jresult ;
40653   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40654   unsigned int result;
40655
40656   arg1 = (Dali::PanGestureDetector *)jarg1;
40657   {
40658     try {
40659       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40660     } catch (std::out_of_range& e) {
40661       {
40662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40663       };
40664     } catch (std::exception& e) {
40665       {
40666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40667       };
40668     } catch (Dali::DaliException e) {
40669       {
40670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40671       };
40672     } catch (...) {
40673       {
40674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40675       };
40676     }
40677   }
40678
40679   jresult = result;
40680   return jresult;
40681 }
40682
40683
40684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40685   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40686   Dali::Radian arg2 ;
40687   Dali::Radian arg3 ;
40688   Dali::Radian *argp2 ;
40689   Dali::Radian *argp3 ;
40690
40691   arg1 = (Dali::PanGestureDetector *)jarg1;
40692   argp2 = (Dali::Radian *)jarg2;
40693   if (!argp2) {
40694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40695     return ;
40696   }
40697   arg2 = *argp2;
40698   argp3 = (Dali::Radian *)jarg3;
40699   if (!argp3) {
40700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40701     return ;
40702   }
40703   arg3 = *argp3;
40704   {
40705     try {
40706       (arg1)->AddAngle(arg2,arg3);
40707     } catch (std::out_of_range& e) {
40708       {
40709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40710       };
40711     } catch (std::exception& e) {
40712       {
40713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40714       };
40715     } catch (Dali::DaliException e) {
40716       {
40717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40718       };
40719     } catch (...) {
40720       {
40721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40722       };
40723     }
40724   }
40725
40726 }
40727
40728
40729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40730   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40731   Dali::Radian arg2 ;
40732   Dali::Radian *argp2 ;
40733
40734   arg1 = (Dali::PanGestureDetector *)jarg1;
40735   argp2 = (Dali::Radian *)jarg2;
40736   if (!argp2) {
40737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40738     return ;
40739   }
40740   arg2 = *argp2;
40741   {
40742     try {
40743       (arg1)->AddAngle(arg2);
40744     } catch (std::out_of_range& e) {
40745       {
40746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40747       };
40748     } catch (std::exception& e) {
40749       {
40750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40751       };
40752     } catch (Dali::DaliException e) {
40753       {
40754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40755       };
40756     } catch (...) {
40757       {
40758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40759       };
40760     }
40761   }
40762
40763 }
40764
40765
40766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40767   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40768   Dali::Radian arg2 ;
40769   Dali::Radian arg3 ;
40770   Dali::Radian *argp2 ;
40771   Dali::Radian *argp3 ;
40772
40773   arg1 = (Dali::PanGestureDetector *)jarg1;
40774   argp2 = (Dali::Radian *)jarg2;
40775   if (!argp2) {
40776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40777     return ;
40778   }
40779   arg2 = *argp2;
40780   argp3 = (Dali::Radian *)jarg3;
40781   if (!argp3) {
40782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40783     return ;
40784   }
40785   arg3 = *argp3;
40786   {
40787     try {
40788       (arg1)->AddDirection(arg2,arg3);
40789     } catch (std::out_of_range& e) {
40790       {
40791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40792       };
40793     } catch (std::exception& e) {
40794       {
40795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40796       };
40797     } catch (Dali::DaliException e) {
40798       {
40799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40800       };
40801     } catch (...) {
40802       {
40803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40804       };
40805     }
40806   }
40807
40808 }
40809
40810
40811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40812   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40813   Dali::Radian arg2 ;
40814   Dali::Radian *argp2 ;
40815
40816   arg1 = (Dali::PanGestureDetector *)jarg1;
40817   argp2 = (Dali::Radian *)jarg2;
40818   if (!argp2) {
40819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40820     return ;
40821   }
40822   arg2 = *argp2;
40823   {
40824     try {
40825       (arg1)->AddDirection(arg2);
40826     } catch (std::out_of_range& e) {
40827       {
40828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40829       };
40830     } catch (std::exception& e) {
40831       {
40832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40833       };
40834     } catch (Dali::DaliException e) {
40835       {
40836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40837       };
40838     } catch (...) {
40839       {
40840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40841       };
40842     }
40843   }
40844
40845 }
40846
40847
40848 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40849   unsigned long jresult ;
40850   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40851   size_t result;
40852
40853   arg1 = (Dali::PanGestureDetector *)jarg1;
40854   {
40855     try {
40856       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40857     } catch (std::out_of_range& e) {
40858       {
40859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40860       };
40861     } catch (std::exception& e) {
40862       {
40863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40864       };
40865     } catch (Dali::DaliException e) {
40866       {
40867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40868       };
40869     } catch (...) {
40870       {
40871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40872       };
40873     }
40874   }
40875
40876   jresult = (unsigned long)result;
40877   return jresult;
40878 }
40879
40880
40881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40882   void * jresult ;
40883   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40884   size_t arg2 ;
40885   Dali::PanGestureDetector::AngleThresholdPair result;
40886
40887   arg1 = (Dali::PanGestureDetector *)jarg1;
40888   arg2 = (size_t)jarg2;
40889   {
40890     try {
40891       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40892     } catch (std::out_of_range& e) {
40893       {
40894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40895       };
40896     } catch (std::exception& e) {
40897       {
40898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40899       };
40900     } catch (Dali::DaliException e) {
40901       {
40902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40903       };
40904     } catch (...) {
40905       {
40906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40907       };
40908     }
40909   }
40910
40911   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40912   return jresult;
40913 }
40914
40915
40916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40917   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40918
40919   arg1 = (Dali::PanGestureDetector *)jarg1;
40920   {
40921     try {
40922       (arg1)->ClearAngles();
40923     } catch (std::out_of_range& e) {
40924       {
40925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40926       };
40927     } catch (std::exception& e) {
40928       {
40929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40930       };
40931     } catch (Dali::DaliException e) {
40932       {
40933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40934       };
40935     } catch (...) {
40936       {
40937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40938       };
40939     }
40940   }
40941
40942 }
40943
40944
40945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40946   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40947   Dali::Radian arg2 ;
40948   Dali::Radian *argp2 ;
40949
40950   arg1 = (Dali::PanGestureDetector *)jarg1;
40951   argp2 = (Dali::Radian *)jarg2;
40952   if (!argp2) {
40953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40954     return ;
40955   }
40956   arg2 = *argp2;
40957   {
40958     try {
40959       (arg1)->RemoveAngle(arg2);
40960     } catch (std::out_of_range& e) {
40961       {
40962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40963       };
40964     } catch (std::exception& e) {
40965       {
40966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40967       };
40968     } catch (Dali::DaliException e) {
40969       {
40970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40971       };
40972     } catch (...) {
40973       {
40974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40975       };
40976     }
40977   }
40978
40979 }
40980
40981
40982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40983   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40984   Dali::Radian arg2 ;
40985   Dali::Radian *argp2 ;
40986
40987   arg1 = (Dali::PanGestureDetector *)jarg1;
40988   argp2 = (Dali::Radian *)jarg2;
40989   if (!argp2) {
40990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40991     return ;
40992   }
40993   arg2 = *argp2;
40994   {
40995     try {
40996       (arg1)->RemoveDirection(arg2);
40997     } catch (std::out_of_range& e) {
40998       {
40999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41000       };
41001     } catch (std::exception& e) {
41002       {
41003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41004       };
41005     } catch (Dali::DaliException e) {
41006       {
41007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41008       };
41009     } catch (...) {
41010       {
41011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41012       };
41013     }
41014   }
41015
41016 }
41017
41018
41019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41020   void * jresult ;
41021   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41022   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41023
41024   arg1 = (Dali::PanGestureDetector *)jarg1;
41025   {
41026     try {
41027       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41028     } catch (std::out_of_range& e) {
41029       {
41030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41031       };
41032     } catch (std::exception& e) {
41033       {
41034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41035       };
41036     } catch (Dali::DaliException e) {
41037       {
41038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41039       };
41040     } catch (...) {
41041       {
41042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41043       };
41044     }
41045   }
41046
41047   jresult = (void *)result;
41048   return jresult;
41049 }
41050
41051
41052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41053   Dali::PanGesture *arg1 = 0 ;
41054
41055   arg1 = (Dali::PanGesture *)jarg1;
41056   if (!arg1) {
41057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41058     return ;
41059   }
41060   {
41061     try {
41062       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41063     } catch (std::out_of_range& e) {
41064       {
41065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41066       };
41067     } catch (std::exception& e) {
41068       {
41069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41070       };
41071     } catch (Dali::DaliException e) {
41072       {
41073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41074       };
41075     } catch (...) {
41076       {
41077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41078       };
41079     }
41080   }
41081
41082 }
41083
41084
41085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41086   void * jresult ;
41087   Dali::PanGesture *result = 0 ;
41088
41089   {
41090     try {
41091       result = (Dali::PanGesture *)new Dali::PanGesture();
41092     } catch (std::out_of_range& e) {
41093       {
41094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41095       };
41096     } catch (std::exception& e) {
41097       {
41098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41099       };
41100     } catch (Dali::DaliException e) {
41101       {
41102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41103       };
41104     } catch (...) {
41105       {
41106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41107       };
41108     }
41109   }
41110
41111   jresult = (void *)result;
41112   return jresult;
41113 }
41114
41115
41116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41117   void * jresult ;
41118   Dali::Gesture::State arg1 ;
41119   Dali::PanGesture *result = 0 ;
41120
41121   arg1 = (Dali::Gesture::State)jarg1;
41122   {
41123     try {
41124       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41125     } catch (std::out_of_range& e) {
41126       {
41127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41128       };
41129     } catch (std::exception& e) {
41130       {
41131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41132       };
41133     } catch (Dali::DaliException e) {
41134       {
41135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41136       };
41137     } catch (...) {
41138       {
41139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41140       };
41141     }
41142   }
41143
41144   jresult = (void *)result;
41145   return jresult;
41146 }
41147
41148
41149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41150   void * jresult ;
41151   Dali::PanGesture *arg1 = 0 ;
41152   Dali::PanGesture *result = 0 ;
41153
41154   arg1 = (Dali::PanGesture *)jarg1;
41155   if (!arg1) {
41156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41157     return 0;
41158   }
41159   {
41160     try {
41161       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41162     } catch (std::out_of_range& e) {
41163       {
41164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41165       };
41166     } catch (std::exception& e) {
41167       {
41168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41169       };
41170     } catch (Dali::DaliException e) {
41171       {
41172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41173       };
41174     } catch (...) {
41175       {
41176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41177       };
41178     }
41179   }
41180
41181   jresult = (void *)result;
41182   return jresult;
41183 }
41184
41185
41186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41187   void * jresult ;
41188   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41189   Dali::PanGesture *arg2 = 0 ;
41190   Dali::PanGesture *result = 0 ;
41191
41192   arg1 = (Dali::PanGesture *)jarg1;
41193   arg2 = (Dali::PanGesture *)jarg2;
41194   if (!arg2) {
41195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41196     return 0;
41197   }
41198   {
41199     try {
41200       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41201     } catch (std::out_of_range& e) {
41202       {
41203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41204       };
41205     } catch (std::exception& e) {
41206       {
41207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41208       };
41209     } catch (Dali::DaliException e) {
41210       {
41211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41212       };
41213     } catch (...) {
41214       {
41215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41216       };
41217     }
41218   }
41219
41220   jresult = (void *)result;
41221   return jresult;
41222 }
41223
41224
41225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41226   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41227
41228   arg1 = (Dali::PanGesture *)jarg1;
41229   {
41230     try {
41231       delete arg1;
41232     } catch (std::out_of_range& e) {
41233       {
41234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41235       };
41236     } catch (std::exception& e) {
41237       {
41238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41239       };
41240     } catch (Dali::DaliException e) {
41241       {
41242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41243       };
41244     } catch (...) {
41245       {
41246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41247       };
41248     }
41249   }
41250
41251 }
41252
41253
41254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41255   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41256   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41257
41258   arg1 = (Dali::PanGesture *)jarg1;
41259   arg2 = (Dali::Vector2 *)jarg2;
41260   if (arg1) (arg1)->velocity = *arg2;
41261 }
41262
41263
41264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41265   void * jresult ;
41266   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41267   Dali::Vector2 *result = 0 ;
41268
41269   arg1 = (Dali::PanGesture *)jarg1;
41270   result = (Dali::Vector2 *)& ((arg1)->velocity);
41271   jresult = (void *)result;
41272   return jresult;
41273 }
41274
41275
41276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41277   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41278   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41279
41280   arg1 = (Dali::PanGesture *)jarg1;
41281   arg2 = (Dali::Vector2 *)jarg2;
41282   if (arg1) (arg1)->displacement = *arg2;
41283 }
41284
41285
41286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41287   void * jresult ;
41288   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41289   Dali::Vector2 *result = 0 ;
41290
41291   arg1 = (Dali::PanGesture *)jarg1;
41292   result = (Dali::Vector2 *)& ((arg1)->displacement);
41293   jresult = (void *)result;
41294   return jresult;
41295 }
41296
41297
41298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41299   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41300   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41301
41302   arg1 = (Dali::PanGesture *)jarg1;
41303   arg2 = (Dali::Vector2 *)jarg2;
41304   if (arg1) (arg1)->position = *arg2;
41305 }
41306
41307
41308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41309   void * jresult ;
41310   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41311   Dali::Vector2 *result = 0 ;
41312
41313   arg1 = (Dali::PanGesture *)jarg1;
41314   result = (Dali::Vector2 *)& ((arg1)->position);
41315   jresult = (void *)result;
41316   return jresult;
41317 }
41318
41319
41320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41321   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41322   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41323
41324   arg1 = (Dali::PanGesture *)jarg1;
41325   arg2 = (Dali::Vector2 *)jarg2;
41326   if (arg1) (arg1)->screenVelocity = *arg2;
41327 }
41328
41329
41330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41331   void * jresult ;
41332   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41333   Dali::Vector2 *result = 0 ;
41334
41335   arg1 = (Dali::PanGesture *)jarg1;
41336   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41337   jresult = (void *)result;
41338   return jresult;
41339 }
41340
41341
41342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41343   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41344   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41345
41346   arg1 = (Dali::PanGesture *)jarg1;
41347   arg2 = (Dali::Vector2 *)jarg2;
41348   if (arg1) (arg1)->screenDisplacement = *arg2;
41349 }
41350
41351
41352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41353   void * jresult ;
41354   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41355   Dali::Vector2 *result = 0 ;
41356
41357   arg1 = (Dali::PanGesture *)jarg1;
41358   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41359   jresult = (void *)result;
41360   return jresult;
41361 }
41362
41363
41364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41365   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41366   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41367
41368   arg1 = (Dali::PanGesture *)jarg1;
41369   arg2 = (Dali::Vector2 *)jarg2;
41370   if (arg1) (arg1)->screenPosition = *arg2;
41371 }
41372
41373
41374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41375   void * jresult ;
41376   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41377   Dali::Vector2 *result = 0 ;
41378
41379   arg1 = (Dali::PanGesture *)jarg1;
41380   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41381   jresult = (void *)result;
41382   return jresult;
41383 }
41384
41385
41386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41387   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41388   unsigned int arg2 ;
41389
41390   arg1 = (Dali::PanGesture *)jarg1;
41391   arg2 = (unsigned int)jarg2;
41392   if (arg1) (arg1)->numberOfTouches = arg2;
41393 }
41394
41395
41396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41397   unsigned int jresult ;
41398   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41399   unsigned int result;
41400
41401   arg1 = (Dali::PanGesture *)jarg1;
41402   result = (unsigned int) ((arg1)->numberOfTouches);
41403   jresult = result;
41404   return jresult;
41405 }
41406
41407
41408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41409   float jresult ;
41410   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41411   float result;
41412
41413   arg1 = (Dali::PanGesture *)jarg1;
41414   {
41415     try {
41416       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41417     } catch (std::out_of_range& e) {
41418       {
41419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41420       };
41421     } catch (std::exception& e) {
41422       {
41423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41424       };
41425     } catch (Dali::DaliException e) {
41426       {
41427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41428       };
41429     } catch (...) {
41430       {
41431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41432       };
41433     }
41434   }
41435
41436   jresult = result;
41437   return jresult;
41438 }
41439
41440
41441 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41442   float jresult ;
41443   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41444   float result;
41445
41446   arg1 = (Dali::PanGesture *)jarg1;
41447   {
41448     try {
41449       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41450     } catch (std::out_of_range& e) {
41451       {
41452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41453       };
41454     } catch (std::exception& e) {
41455       {
41456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41457       };
41458     } catch (Dali::DaliException e) {
41459       {
41460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41461       };
41462     } catch (...) {
41463       {
41464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41465       };
41466     }
41467   }
41468
41469   jresult = result;
41470   return jresult;
41471 }
41472
41473
41474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41475   float jresult ;
41476   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41477   float result;
41478
41479   arg1 = (Dali::PanGesture *)jarg1;
41480   {
41481     try {
41482       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41483     } catch (std::out_of_range& e) {
41484       {
41485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41486       };
41487     } catch (std::exception& e) {
41488       {
41489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41490       };
41491     } catch (Dali::DaliException e) {
41492       {
41493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41494       };
41495     } catch (...) {
41496       {
41497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41498       };
41499     }
41500   }
41501
41502   jresult = result;
41503   return jresult;
41504 }
41505
41506
41507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41508   float jresult ;
41509   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41510   float result;
41511
41512   arg1 = (Dali::PanGesture *)jarg1;
41513   {
41514     try {
41515       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41516     } catch (std::out_of_range& e) {
41517       {
41518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41519       };
41520     } catch (std::exception& e) {
41521       {
41522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41523       };
41524     } catch (Dali::DaliException e) {
41525       {
41526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41527       };
41528     } catch (...) {
41529       {
41530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41531       };
41532     }
41533   }
41534
41535   jresult = result;
41536   return jresult;
41537 }
41538
41539
41540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41541   void * jresult ;
41542   Dali::PinchGestureDetector *result = 0 ;
41543
41544   {
41545     try {
41546       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41547     } catch (std::out_of_range& e) {
41548       {
41549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41550       };
41551     } catch (std::exception& e) {
41552       {
41553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41554       };
41555     } catch (Dali::DaliException e) {
41556       {
41557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41558       };
41559     } catch (...) {
41560       {
41561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41562       };
41563     }
41564   }
41565
41566   jresult = (void *)result;
41567   return jresult;
41568 }
41569
41570
41571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41572   void * jresult ;
41573   Dali::PinchGestureDetector result;
41574
41575   {
41576     try {
41577       result = Dali::PinchGestureDetector::New();
41578     } catch (std::out_of_range& e) {
41579       {
41580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41581       };
41582     } catch (std::exception& e) {
41583       {
41584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41585       };
41586     } catch (Dali::DaliException e) {
41587       {
41588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41589       };
41590     } catch (...) {
41591       {
41592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41593       };
41594     }
41595   }
41596
41597   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41598   return jresult;
41599 }
41600
41601
41602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41603   void * jresult ;
41604   Dali::BaseHandle arg1 ;
41605   Dali::BaseHandle *argp1 ;
41606   Dali::PinchGestureDetector result;
41607
41608   argp1 = (Dali::BaseHandle *)jarg1;
41609   if (!argp1) {
41610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41611     return 0;
41612   }
41613   arg1 = *argp1;
41614   {
41615     try {
41616       result = Dali::PinchGestureDetector::DownCast(arg1);
41617     } catch (std::out_of_range& e) {
41618       {
41619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41620       };
41621     } catch (std::exception& e) {
41622       {
41623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41624       };
41625     } catch (Dali::DaliException e) {
41626       {
41627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41628       };
41629     } catch (...) {
41630       {
41631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41632       };
41633     }
41634   }
41635
41636   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41637   return jresult;
41638 }
41639
41640
41641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41642   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41643
41644   arg1 = (Dali::PinchGestureDetector *)jarg1;
41645   {
41646     try {
41647       delete arg1;
41648     } catch (std::out_of_range& e) {
41649       {
41650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41651       };
41652     } catch (std::exception& e) {
41653       {
41654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41655       };
41656     } catch (Dali::DaliException e) {
41657       {
41658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41659       };
41660     } catch (...) {
41661       {
41662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41663       };
41664     }
41665   }
41666
41667 }
41668
41669
41670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41671   void * jresult ;
41672   Dali::PinchGestureDetector *arg1 = 0 ;
41673   Dali::PinchGestureDetector *result = 0 ;
41674
41675   arg1 = (Dali::PinchGestureDetector *)jarg1;
41676   if (!arg1) {
41677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41678     return 0;
41679   }
41680   {
41681     try {
41682       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41683     } catch (std::out_of_range& e) {
41684       {
41685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41686       };
41687     } catch (std::exception& e) {
41688       {
41689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41690       };
41691     } catch (Dali::DaliException e) {
41692       {
41693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41694       };
41695     } catch (...) {
41696       {
41697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41698       };
41699     }
41700   }
41701
41702   jresult = (void *)result;
41703   return jresult;
41704 }
41705
41706
41707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41708   void * jresult ;
41709   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41710   Dali::PinchGestureDetector *arg2 = 0 ;
41711   Dali::PinchGestureDetector *result = 0 ;
41712
41713   arg1 = (Dali::PinchGestureDetector *)jarg1;
41714   arg2 = (Dali::PinchGestureDetector *)jarg2;
41715   if (!arg2) {
41716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41717     return 0;
41718   }
41719   {
41720     try {
41721       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41722     } catch (std::out_of_range& e) {
41723       {
41724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41725       };
41726     } catch (std::exception& e) {
41727       {
41728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41729       };
41730     } catch (Dali::DaliException e) {
41731       {
41732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41733       };
41734     } catch (...) {
41735       {
41736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41737       };
41738     }
41739   }
41740
41741   jresult = (void *)result;
41742   return jresult;
41743 }
41744
41745
41746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41747   void * jresult ;
41748   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41749   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41750
41751   arg1 = (Dali::PinchGestureDetector *)jarg1;
41752   {
41753     try {
41754       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41755     } catch (std::out_of_range& e) {
41756       {
41757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41758       };
41759     } catch (std::exception& e) {
41760       {
41761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41762       };
41763     } catch (Dali::DaliException e) {
41764       {
41765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41766       };
41767     } catch (...) {
41768       {
41769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41770       };
41771     }
41772   }
41773
41774   jresult = (void *)result;
41775   return jresult;
41776 }
41777
41778
41779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41780   void * jresult ;
41781   Dali::Gesture::State arg1 ;
41782   Dali::PinchGesture *result = 0 ;
41783
41784   arg1 = (Dali::Gesture::State)jarg1;
41785   {
41786     try {
41787       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41788     } catch (std::out_of_range& e) {
41789       {
41790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41791       };
41792     } catch (std::exception& e) {
41793       {
41794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41795       };
41796     } catch (Dali::DaliException e) {
41797       {
41798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41799       };
41800     } catch (...) {
41801       {
41802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41803       };
41804     }
41805   }
41806
41807   jresult = (void *)result;
41808   return jresult;
41809 }
41810
41811
41812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41813   void * jresult ;
41814   Dali::PinchGesture *arg1 = 0 ;
41815   Dali::PinchGesture *result = 0 ;
41816
41817   arg1 = (Dali::PinchGesture *)jarg1;
41818   if (!arg1) {
41819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41820     return 0;
41821   }
41822   {
41823     try {
41824       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41825     } catch (std::out_of_range& e) {
41826       {
41827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41828       };
41829     } catch (std::exception& e) {
41830       {
41831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41832       };
41833     } catch (Dali::DaliException e) {
41834       {
41835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41836       };
41837     } catch (...) {
41838       {
41839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41840       };
41841     }
41842   }
41843
41844   jresult = (void *)result;
41845   return jresult;
41846 }
41847
41848
41849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41850   void * jresult ;
41851   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41852   Dali::PinchGesture *arg2 = 0 ;
41853   Dali::PinchGesture *result = 0 ;
41854
41855   arg1 = (Dali::PinchGesture *)jarg1;
41856   arg2 = (Dali::PinchGesture *)jarg2;
41857   if (!arg2) {
41858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41859     return 0;
41860   }
41861   {
41862     try {
41863       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41864     } catch (std::out_of_range& e) {
41865       {
41866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41867       };
41868     } catch (std::exception& e) {
41869       {
41870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41871       };
41872     } catch (Dali::DaliException e) {
41873       {
41874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41875       };
41876     } catch (...) {
41877       {
41878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41879       };
41880     }
41881   }
41882
41883   jresult = (void *)result;
41884   return jresult;
41885 }
41886
41887
41888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41889   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41890
41891   arg1 = (Dali::PinchGesture *)jarg1;
41892   {
41893     try {
41894       delete arg1;
41895     } catch (std::out_of_range& e) {
41896       {
41897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41898       };
41899     } catch (std::exception& e) {
41900       {
41901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41902       };
41903     } catch (Dali::DaliException e) {
41904       {
41905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41906       };
41907     } catch (...) {
41908       {
41909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41910       };
41911     }
41912   }
41913
41914 }
41915
41916
41917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41918   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41919   float arg2 ;
41920
41921   arg1 = (Dali::PinchGesture *)jarg1;
41922   arg2 = (float)jarg2;
41923   if (arg1) (arg1)->scale = arg2;
41924 }
41925
41926
41927 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41928   float jresult ;
41929   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41930   float result;
41931
41932   arg1 = (Dali::PinchGesture *)jarg1;
41933   result = (float) ((arg1)->scale);
41934   jresult = result;
41935   return jresult;
41936 }
41937
41938
41939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41940   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41941   float arg2 ;
41942
41943   arg1 = (Dali::PinchGesture *)jarg1;
41944   arg2 = (float)jarg2;
41945   if (arg1) (arg1)->speed = arg2;
41946 }
41947
41948
41949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41950   float jresult ;
41951   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41952   float result;
41953
41954   arg1 = (Dali::PinchGesture *)jarg1;
41955   result = (float) ((arg1)->speed);
41956   jresult = result;
41957   return jresult;
41958 }
41959
41960
41961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41962   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41963   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41964
41965   arg1 = (Dali::PinchGesture *)jarg1;
41966   arg2 = (Dali::Vector2 *)jarg2;
41967   if (arg1) (arg1)->screenCenterPoint = *arg2;
41968 }
41969
41970
41971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41972   void * jresult ;
41973   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41974   Dali::Vector2 *result = 0 ;
41975
41976   arg1 = (Dali::PinchGesture *)jarg1;
41977   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41978   jresult = (void *)result;
41979   return jresult;
41980 }
41981
41982
41983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41984   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41985   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41986
41987   arg1 = (Dali::PinchGesture *)jarg1;
41988   arg2 = (Dali::Vector2 *)jarg2;
41989   if (arg1) (arg1)->localCenterPoint = *arg2;
41990 }
41991
41992
41993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41994   void * jresult ;
41995   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41996   Dali::Vector2 *result = 0 ;
41997
41998   arg1 = (Dali::PinchGesture *)jarg1;
41999   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42000   jresult = (void *)result;
42001   return jresult;
42002 }
42003
42004
42005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42006   void * jresult ;
42007   Dali::TapGestureDetector *result = 0 ;
42008
42009   {
42010     try {
42011       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42012     } catch (std::out_of_range& e) {
42013       {
42014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42015       };
42016     } catch (std::exception& e) {
42017       {
42018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42019       };
42020     } catch (Dali::DaliException e) {
42021       {
42022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42023       };
42024     } catch (...) {
42025       {
42026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42027       };
42028     }
42029   }
42030
42031   jresult = (void *)result;
42032   return jresult;
42033 }
42034
42035
42036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42037   void * jresult ;
42038   Dali::TapGestureDetector result;
42039
42040   {
42041     try {
42042       result = Dali::TapGestureDetector::New();
42043     } catch (std::out_of_range& e) {
42044       {
42045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42046       };
42047     } catch (std::exception& e) {
42048       {
42049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42050       };
42051     } catch (Dali::DaliException e) {
42052       {
42053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42054       };
42055     } catch (...) {
42056       {
42057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42058       };
42059     }
42060   }
42061
42062   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42063   return jresult;
42064 }
42065
42066
42067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42068   void * jresult ;
42069   unsigned int arg1 ;
42070   Dali::TapGestureDetector result;
42071
42072   arg1 = (unsigned int)jarg1;
42073   {
42074     try {
42075       result = Dali::TapGestureDetector::New(arg1);
42076     } catch (std::out_of_range& e) {
42077       {
42078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42079       };
42080     } catch (std::exception& e) {
42081       {
42082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42083       };
42084     } catch (Dali::DaliException e) {
42085       {
42086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42087       };
42088     } catch (...) {
42089       {
42090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42091       };
42092     }
42093   }
42094
42095   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42096   return jresult;
42097 }
42098
42099
42100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42101   void * jresult ;
42102   Dali::BaseHandle arg1 ;
42103   Dali::BaseHandle *argp1 ;
42104   Dali::TapGestureDetector result;
42105
42106   argp1 = (Dali::BaseHandle *)jarg1;
42107   if (!argp1) {
42108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42109     return 0;
42110   }
42111   arg1 = *argp1;
42112   {
42113     try {
42114       result = Dali::TapGestureDetector::DownCast(arg1);
42115     } catch (std::out_of_range& e) {
42116       {
42117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42118       };
42119     } catch (std::exception& e) {
42120       {
42121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42122       };
42123     } catch (Dali::DaliException e) {
42124       {
42125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42126       };
42127     } catch (...) {
42128       {
42129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42130       };
42131     }
42132   }
42133
42134   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42135   return jresult;
42136 }
42137
42138
42139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42140   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42141
42142   arg1 = (Dali::TapGestureDetector *)jarg1;
42143   {
42144     try {
42145       delete arg1;
42146     } catch (std::out_of_range& e) {
42147       {
42148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42149       };
42150     } catch (std::exception& e) {
42151       {
42152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42153       };
42154     } catch (Dali::DaliException e) {
42155       {
42156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42157       };
42158     } catch (...) {
42159       {
42160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42161       };
42162     }
42163   }
42164
42165 }
42166
42167
42168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42169   void * jresult ;
42170   Dali::TapGestureDetector *arg1 = 0 ;
42171   Dali::TapGestureDetector *result = 0 ;
42172
42173   arg1 = (Dali::TapGestureDetector *)jarg1;
42174   if (!arg1) {
42175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42176     return 0;
42177   }
42178   {
42179     try {
42180       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42181     } catch (std::out_of_range& e) {
42182       {
42183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42184       };
42185     } catch (std::exception& e) {
42186       {
42187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42188       };
42189     } catch (Dali::DaliException e) {
42190       {
42191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42192       };
42193     } catch (...) {
42194       {
42195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42196       };
42197     }
42198   }
42199
42200   jresult = (void *)result;
42201   return jresult;
42202 }
42203
42204
42205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42206   void * jresult ;
42207   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42208   Dali::TapGestureDetector *arg2 = 0 ;
42209   Dali::TapGestureDetector *result = 0 ;
42210
42211   arg1 = (Dali::TapGestureDetector *)jarg1;
42212   arg2 = (Dali::TapGestureDetector *)jarg2;
42213   if (!arg2) {
42214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42215     return 0;
42216   }
42217   {
42218     try {
42219       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42220     } catch (std::out_of_range& e) {
42221       {
42222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42223       };
42224     } catch (std::exception& e) {
42225       {
42226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42227       };
42228     } catch (Dali::DaliException e) {
42229       {
42230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42231       };
42232     } catch (...) {
42233       {
42234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42235       };
42236     }
42237   }
42238
42239   jresult = (void *)result;
42240   return jresult;
42241 }
42242
42243
42244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42245   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42246   unsigned int arg2 ;
42247
42248   arg1 = (Dali::TapGestureDetector *)jarg1;
42249   arg2 = (unsigned int)jarg2;
42250   {
42251     try {
42252       (arg1)->SetMinimumTapsRequired(arg2);
42253     } catch (std::out_of_range& e) {
42254       {
42255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42256       };
42257     } catch (std::exception& e) {
42258       {
42259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42260       };
42261     } catch (Dali::DaliException e) {
42262       {
42263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42264       };
42265     } catch (...) {
42266       {
42267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42268       };
42269     }
42270   }
42271
42272 }
42273
42274
42275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42276   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42277   unsigned int arg2 ;
42278
42279   arg1 = (Dali::TapGestureDetector *)jarg1;
42280   arg2 = (unsigned int)jarg2;
42281   {
42282     try {
42283       (arg1)->SetMaximumTapsRequired(arg2);
42284     } catch (std::out_of_range& e) {
42285       {
42286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42287       };
42288     } catch (std::exception& e) {
42289       {
42290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42291       };
42292     } catch (Dali::DaliException e) {
42293       {
42294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42295       };
42296     } catch (...) {
42297       {
42298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42299       };
42300     }
42301   }
42302
42303 }
42304
42305
42306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42307   unsigned int jresult ;
42308   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42309   unsigned int result;
42310
42311   arg1 = (Dali::TapGestureDetector *)jarg1;
42312   {
42313     try {
42314       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42315     } catch (std::out_of_range& e) {
42316       {
42317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42318       };
42319     } catch (std::exception& e) {
42320       {
42321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42322       };
42323     } catch (Dali::DaliException e) {
42324       {
42325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42326       };
42327     } catch (...) {
42328       {
42329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42330       };
42331     }
42332   }
42333
42334   jresult = result;
42335   return jresult;
42336 }
42337
42338
42339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42340   unsigned int jresult ;
42341   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42342   unsigned int result;
42343
42344   arg1 = (Dali::TapGestureDetector *)jarg1;
42345   {
42346     try {
42347       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42348     } catch (std::out_of_range& e) {
42349       {
42350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42351       };
42352     } catch (std::exception& e) {
42353       {
42354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42355       };
42356     } catch (Dali::DaliException e) {
42357       {
42358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42359       };
42360     } catch (...) {
42361       {
42362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42363       };
42364     }
42365   }
42366
42367   jresult = result;
42368   return jresult;
42369 }
42370
42371
42372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42373   void * jresult ;
42374   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42375   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42376
42377   arg1 = (Dali::TapGestureDetector *)jarg1;
42378   {
42379     try {
42380       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42381     } catch (std::out_of_range& e) {
42382       {
42383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42384       };
42385     } catch (std::exception& e) {
42386       {
42387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42388       };
42389     } catch (Dali::DaliException e) {
42390       {
42391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42392       };
42393     } catch (...) {
42394       {
42395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42396       };
42397     }
42398   }
42399
42400   jresult = (void *)result;
42401   return jresult;
42402 }
42403
42404
42405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42406   void * jresult ;
42407   Dali::TapGesture *result = 0 ;
42408
42409   {
42410     try {
42411       result = (Dali::TapGesture *)new Dali::TapGesture();
42412     } catch (std::out_of_range& e) {
42413       {
42414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42415       };
42416     } catch (std::exception& e) {
42417       {
42418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42419       };
42420     } catch (Dali::DaliException e) {
42421       {
42422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42423       };
42424     } catch (...) {
42425       {
42426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42427       };
42428     }
42429   }
42430
42431   jresult = (void *)result;
42432   return jresult;
42433 }
42434
42435
42436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42437   void * jresult ;
42438   Dali::TapGesture *arg1 = 0 ;
42439   Dali::TapGesture *result = 0 ;
42440
42441   arg1 = (Dali::TapGesture *)jarg1;
42442   if (!arg1) {
42443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42444     return 0;
42445   }
42446   {
42447     try {
42448       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42449     } catch (std::out_of_range& e) {
42450       {
42451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42452       };
42453     } catch (std::exception& e) {
42454       {
42455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42456       };
42457     } catch (Dali::DaliException e) {
42458       {
42459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42460       };
42461     } catch (...) {
42462       {
42463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42464       };
42465     }
42466   }
42467
42468   jresult = (void *)result;
42469   return jresult;
42470 }
42471
42472
42473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42474   void * jresult ;
42475   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42476   Dali::TapGesture *arg2 = 0 ;
42477   Dali::TapGesture *result = 0 ;
42478
42479   arg1 = (Dali::TapGesture *)jarg1;
42480   arg2 = (Dali::TapGesture *)jarg2;
42481   if (!arg2) {
42482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42483     return 0;
42484   }
42485   {
42486     try {
42487       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42488     } catch (std::out_of_range& e) {
42489       {
42490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42491       };
42492     } catch (std::exception& e) {
42493       {
42494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42495       };
42496     } catch (Dali::DaliException e) {
42497       {
42498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42499       };
42500     } catch (...) {
42501       {
42502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42503       };
42504     }
42505   }
42506
42507   jresult = (void *)result;
42508   return jresult;
42509 }
42510
42511
42512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42513   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42514
42515   arg1 = (Dali::TapGesture *)jarg1;
42516   {
42517     try {
42518       delete arg1;
42519     } catch (std::out_of_range& e) {
42520       {
42521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42522       };
42523     } catch (std::exception& e) {
42524       {
42525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42526       };
42527     } catch (Dali::DaliException e) {
42528       {
42529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42530       };
42531     } catch (...) {
42532       {
42533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42534       };
42535     }
42536   }
42537
42538 }
42539
42540
42541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42542   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42543   unsigned int arg2 ;
42544
42545   arg1 = (Dali::TapGesture *)jarg1;
42546   arg2 = (unsigned int)jarg2;
42547   if (arg1) (arg1)->numberOfTaps = arg2;
42548 }
42549
42550
42551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42552   unsigned int jresult ;
42553   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42554   unsigned int result;
42555
42556   arg1 = (Dali::TapGesture *)jarg1;
42557   result = (unsigned int) ((arg1)->numberOfTaps);
42558   jresult = result;
42559   return jresult;
42560 }
42561
42562
42563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42564   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42565   unsigned int arg2 ;
42566
42567   arg1 = (Dali::TapGesture *)jarg1;
42568   arg2 = (unsigned int)jarg2;
42569   if (arg1) (arg1)->numberOfTouches = arg2;
42570 }
42571
42572
42573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42574   unsigned int jresult ;
42575   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42576   unsigned int result;
42577
42578   arg1 = (Dali::TapGesture *)jarg1;
42579   result = (unsigned int) ((arg1)->numberOfTouches);
42580   jresult = result;
42581   return jresult;
42582 }
42583
42584
42585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42586   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42587   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42588
42589   arg1 = (Dali::TapGesture *)jarg1;
42590   arg2 = (Dali::Vector2 *)jarg2;
42591   if (arg1) (arg1)->screenPoint = *arg2;
42592 }
42593
42594
42595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42596   void * jresult ;
42597   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42598   Dali::Vector2 *result = 0 ;
42599
42600   arg1 = (Dali::TapGesture *)jarg1;
42601   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42602   jresult = (void *)result;
42603   return jresult;
42604 }
42605
42606
42607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42608   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42609   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42610
42611   arg1 = (Dali::TapGesture *)jarg1;
42612   arg2 = (Dali::Vector2 *)jarg2;
42613   if (arg1) (arg1)->localPoint = *arg2;
42614 }
42615
42616
42617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42618   void * jresult ;
42619   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42620   Dali::Vector2 *result = 0 ;
42621
42622   arg1 = (Dali::TapGesture *)jarg1;
42623   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42624   jresult = (void *)result;
42625   return jresult;
42626 }
42627
42628
42629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42630   void * jresult ;
42631   Dali::AlphaFunction *result = 0 ;
42632
42633   {
42634     try {
42635       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42636     } catch (std::out_of_range& e) {
42637       {
42638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42639       };
42640     } catch (std::exception& e) {
42641       {
42642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42643       };
42644     } catch (Dali::DaliException e) {
42645       {
42646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42647       };
42648     } catch (...) {
42649       {
42650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42651       };
42652     }
42653   }
42654
42655   jresult = (void *)result;
42656   return jresult;
42657 }
42658
42659
42660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42661   void * jresult ;
42662   Dali::AlphaFunction::BuiltinFunction arg1 ;
42663   Dali::AlphaFunction *result = 0 ;
42664
42665   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42666   {
42667     try {
42668       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42669     } catch (std::out_of_range& e) {
42670       {
42671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42672       };
42673     } catch (std::exception& e) {
42674       {
42675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42676       };
42677     } catch (Dali::DaliException e) {
42678       {
42679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42680       };
42681     } catch (...) {
42682       {
42683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42684       };
42685     }
42686   }
42687
42688   jresult = (void *)result;
42689   return jresult;
42690 }
42691
42692
42693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42694   void * jresult ;
42695   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42696   Dali::AlphaFunction *result = 0 ;
42697
42698   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42699   {
42700     try {
42701       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42702     } catch (std::out_of_range& e) {
42703       {
42704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42705       };
42706     } catch (std::exception& e) {
42707       {
42708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42709       };
42710     } catch (Dali::DaliException e) {
42711       {
42712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42713       };
42714     } catch (...) {
42715       {
42716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42717       };
42718     }
42719   }
42720
42721   jresult = (void *)result;
42722   return jresult;
42723 }
42724
42725
42726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42727   void * jresult ;
42728   Dali::Vector2 *arg1 = 0 ;
42729   Dali::Vector2 *arg2 = 0 ;
42730   Dali::AlphaFunction *result = 0 ;
42731
42732   arg1 = (Dali::Vector2 *)jarg1;
42733   if (!arg1) {
42734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42735     return 0;
42736   }
42737   arg2 = (Dali::Vector2 *)jarg2;
42738   if (!arg2) {
42739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42740     return 0;
42741   }
42742   {
42743     try {
42744       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42745     } catch (std::out_of_range& e) {
42746       {
42747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42748       };
42749     } catch (std::exception& e) {
42750       {
42751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42752       };
42753     } catch (Dali::DaliException e) {
42754       {
42755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42756       };
42757     } catch (...) {
42758       {
42759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42760       };
42761     }
42762   }
42763
42764   jresult = (void *)result;
42765   return jresult;
42766 }
42767
42768
42769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42770   void * jresult ;
42771   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42772   Dali::Vector4 result;
42773
42774   arg1 = (Dali::AlphaFunction *)jarg1;
42775   {
42776     try {
42777       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42778     } catch (std::out_of_range& e) {
42779       {
42780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42781       };
42782     } catch (std::exception& e) {
42783       {
42784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42785       };
42786     } catch (Dali::DaliException e) {
42787       {
42788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42789       };
42790     } catch (...) {
42791       {
42792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42793       };
42794     }
42795   }
42796
42797   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42798   return jresult;
42799 }
42800
42801
42802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42803   void * jresult ;
42804   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42805   Dali::AlphaFunctionPrototype result;
42806
42807   arg1 = (Dali::AlphaFunction *)jarg1;
42808   {
42809     try {
42810       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42811     } catch (std::out_of_range& e) {
42812       {
42813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42814       };
42815     } catch (std::exception& e) {
42816       {
42817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42818       };
42819     } catch (Dali::DaliException e) {
42820       {
42821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42822       };
42823     } catch (...) {
42824       {
42825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42826       };
42827     }
42828   }
42829
42830   jresult = (void *)result;
42831   return jresult;
42832 }
42833
42834
42835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42836   int jresult ;
42837   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42838   Dali::AlphaFunction::BuiltinFunction result;
42839
42840   arg1 = (Dali::AlphaFunction *)jarg1;
42841   {
42842     try {
42843       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42844     } catch (std::out_of_range& e) {
42845       {
42846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42847       };
42848     } catch (std::exception& e) {
42849       {
42850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42851       };
42852     } catch (Dali::DaliException e) {
42853       {
42854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42855       };
42856     } catch (...) {
42857       {
42858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42859       };
42860     }
42861   }
42862
42863   jresult = (int)result;
42864   return jresult;
42865 }
42866
42867
42868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42869   int jresult ;
42870   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42871   Dali::AlphaFunction::Mode result;
42872
42873   arg1 = (Dali::AlphaFunction *)jarg1;
42874   {
42875     try {
42876       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42877     } catch (std::out_of_range& e) {
42878       {
42879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42880       };
42881     } catch (std::exception& e) {
42882       {
42883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42884       };
42885     } catch (Dali::DaliException e) {
42886       {
42887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42888       };
42889     } catch (...) {
42890       {
42891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42892       };
42893     }
42894   }
42895
42896   jresult = (int)result;
42897   return jresult;
42898 }
42899
42900
42901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42902   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42903
42904   arg1 = (Dali::AlphaFunction *)jarg1;
42905   {
42906     try {
42907       delete arg1;
42908     } catch (std::out_of_range& e) {
42909       {
42910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42911       };
42912     } catch (std::exception& e) {
42913       {
42914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42915       };
42916     } catch (Dali::DaliException e) {
42917       {
42918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42919       };
42920     } catch (...) {
42921       {
42922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42923       };
42924     }
42925   }
42926
42927 }
42928
42929
42930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42931   void * jresult ;
42932   Dali::KeyFrames result;
42933
42934   {
42935     try {
42936       result = Dali::KeyFrames::New();
42937     } catch (std::out_of_range& e) {
42938       {
42939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42940       };
42941     } catch (std::exception& e) {
42942       {
42943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42944       };
42945     } catch (Dali::DaliException e) {
42946       {
42947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42948       };
42949     } catch (...) {
42950       {
42951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42952       };
42953     }
42954   }
42955
42956   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42957   return jresult;
42958 }
42959
42960
42961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42962   void * jresult ;
42963   Dali::BaseHandle arg1 ;
42964   Dali::BaseHandle *argp1 ;
42965   Dali::KeyFrames result;
42966
42967   argp1 = (Dali::BaseHandle *)jarg1;
42968   if (!argp1) {
42969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42970     return 0;
42971   }
42972   arg1 = *argp1;
42973   {
42974     try {
42975       result = Dali::KeyFrames::DownCast(arg1);
42976     } catch (std::out_of_range& e) {
42977       {
42978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42979       };
42980     } catch (std::exception& e) {
42981       {
42982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42983       };
42984     } catch (Dali::DaliException e) {
42985       {
42986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42987       };
42988     } catch (...) {
42989       {
42990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42991       };
42992     }
42993   }
42994
42995   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42996   return jresult;
42997 }
42998
42999
43000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43001   void * jresult ;
43002   Dali::KeyFrames *result = 0 ;
43003
43004   {
43005     try {
43006       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43007     } catch (std::out_of_range& e) {
43008       {
43009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43010       };
43011     } catch (std::exception& e) {
43012       {
43013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43014       };
43015     } catch (Dali::DaliException e) {
43016       {
43017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43018       };
43019     } catch (...) {
43020       {
43021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43022       };
43023     }
43024   }
43025
43026   jresult = (void *)result;
43027   return jresult;
43028 }
43029
43030
43031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43032   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43033
43034   arg1 = (Dali::KeyFrames *)jarg1;
43035   {
43036     try {
43037       delete arg1;
43038     } catch (std::out_of_range& e) {
43039       {
43040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43041       };
43042     } catch (std::exception& e) {
43043       {
43044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43045       };
43046     } catch (Dali::DaliException e) {
43047       {
43048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43049       };
43050     } catch (...) {
43051       {
43052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43053       };
43054     }
43055   }
43056
43057 }
43058
43059
43060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43061   void * jresult ;
43062   Dali::KeyFrames *arg1 = 0 ;
43063   Dali::KeyFrames *result = 0 ;
43064
43065   arg1 = (Dali::KeyFrames *)jarg1;
43066   if (!arg1) {
43067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43068     return 0;
43069   }
43070   {
43071     try {
43072       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43073     } catch (std::out_of_range& e) {
43074       {
43075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43076       };
43077     } catch (std::exception& e) {
43078       {
43079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43080       };
43081     } catch (Dali::DaliException e) {
43082       {
43083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43084       };
43085     } catch (...) {
43086       {
43087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43088       };
43089     }
43090   }
43091
43092   jresult = (void *)result;
43093   return jresult;
43094 }
43095
43096
43097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43098   void * jresult ;
43099   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43100   Dali::KeyFrames *arg2 = 0 ;
43101   Dali::KeyFrames *result = 0 ;
43102
43103   arg1 = (Dali::KeyFrames *)jarg1;
43104   arg2 = (Dali::KeyFrames *)jarg2;
43105   if (!arg2) {
43106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43107     return 0;
43108   }
43109   {
43110     try {
43111       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43112     } catch (std::out_of_range& e) {
43113       {
43114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43115       };
43116     } catch (std::exception& e) {
43117       {
43118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43119       };
43120     } catch (Dali::DaliException e) {
43121       {
43122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43123       };
43124     } catch (...) {
43125       {
43126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43127       };
43128     }
43129   }
43130
43131   jresult = (void *)result;
43132   return jresult;
43133 }
43134
43135
43136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43137   int jresult ;
43138   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43139   Dali::Property::Type result;
43140
43141   arg1 = (Dali::KeyFrames *)jarg1;
43142   {
43143     try {
43144       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43145     } catch (std::out_of_range& e) {
43146       {
43147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43148       };
43149     } catch (std::exception& e) {
43150       {
43151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43152       };
43153     } catch (Dali::DaliException e) {
43154       {
43155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43156       };
43157     } catch (...) {
43158       {
43159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43160       };
43161     }
43162   }
43163
43164   jresult = (int)result;
43165   return jresult;
43166 }
43167
43168
43169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43170   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43171   float arg2 ;
43172   Dali::Property::Value arg3 ;
43173   Dali::Property::Value *argp3 ;
43174
43175   arg1 = (Dali::KeyFrames *)jarg1;
43176   arg2 = (float)jarg2;
43177   argp3 = (Dali::Property::Value *)jarg3;
43178   if (!argp3) {
43179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43180     return ;
43181   }
43182   arg3 = *argp3;
43183   {
43184     try {
43185       (arg1)->Add(arg2,arg3);
43186     } catch (std::out_of_range& e) {
43187       {
43188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43189       };
43190     } catch (std::exception& e) {
43191       {
43192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43193       };
43194     } catch (Dali::DaliException e) {
43195       {
43196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43197       };
43198     } catch (...) {
43199       {
43200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43201       };
43202     }
43203   }
43204
43205 }
43206
43207
43208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43209   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43210   float arg2 ;
43211   Dali::Property::Value arg3 ;
43212   Dali::AlphaFunction arg4 ;
43213   Dali::Property::Value *argp3 ;
43214   Dali::AlphaFunction *argp4 ;
43215
43216   arg1 = (Dali::KeyFrames *)jarg1;
43217   arg2 = (float)jarg2;
43218   argp3 = (Dali::Property::Value *)jarg3;
43219   if (!argp3) {
43220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43221     return ;
43222   }
43223   arg3 = *argp3;
43224   argp4 = (Dali::AlphaFunction *)jarg4;
43225   if (!argp4) {
43226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43227     return ;
43228   }
43229   arg4 = *argp4;
43230   {
43231     try {
43232       (arg1)->Add(arg2,arg3,arg4);
43233     } catch (std::out_of_range& e) {
43234       {
43235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43236       };
43237     } catch (std::exception& e) {
43238       {
43239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43240       };
43241     } catch (Dali::DaliException e) {
43242       {
43243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43244       };
43245     } catch (...) {
43246       {
43247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43248       };
43249     }
43250   }
43251
43252 }
43253
43254
43255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43256   int jresult ;
43257   int result;
43258
43259   result = (int)Dali::Path::Property::POINTS;
43260   jresult = (int)result;
43261   return jresult;
43262 }
43263
43264
43265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43266   int jresult ;
43267   int result;
43268
43269   result = (int)Dali::Path::Property::CONTROL_POINTS;
43270   jresult = (int)result;
43271   return jresult;
43272 }
43273
43274
43275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43276   void * jresult ;
43277   Dali::Path::Property *result = 0 ;
43278
43279   {
43280     try {
43281       result = (Dali::Path::Property *)new Dali::Path::Property();
43282     } catch (std::out_of_range& e) {
43283       {
43284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43285       };
43286     } catch (std::exception& e) {
43287       {
43288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43289       };
43290     } catch (Dali::DaliException e) {
43291       {
43292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43293       };
43294     } catch (...) {
43295       {
43296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43297       };
43298     }
43299   }
43300
43301   jresult = (void *)result;
43302   return jresult;
43303 }
43304
43305
43306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43307   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43308
43309   arg1 = (Dali::Path::Property *)jarg1;
43310   {
43311     try {
43312       delete arg1;
43313     } catch (std::out_of_range& e) {
43314       {
43315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43316       };
43317     } catch (std::exception& e) {
43318       {
43319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43320       };
43321     } catch (Dali::DaliException e) {
43322       {
43323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43324       };
43325     } catch (...) {
43326       {
43327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43328       };
43329     }
43330   }
43331
43332 }
43333
43334
43335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43336   void * jresult ;
43337   Dali::Path result;
43338
43339   {
43340     try {
43341       result = Dali::Path::New();
43342     } catch (std::out_of_range& e) {
43343       {
43344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43345       };
43346     } catch (std::exception& e) {
43347       {
43348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43349       };
43350     } catch (Dali::DaliException e) {
43351       {
43352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43353       };
43354     } catch (...) {
43355       {
43356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43357       };
43358     }
43359   }
43360
43361   jresult = new Dali::Path((const Dali::Path &)result);
43362   return jresult;
43363 }
43364
43365
43366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43367   void * jresult ;
43368   Dali::BaseHandle arg1 ;
43369   Dali::BaseHandle *argp1 ;
43370   Dali::Path result;
43371
43372   argp1 = (Dali::BaseHandle *)jarg1;
43373   if (!argp1) {
43374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43375     return 0;
43376   }
43377   arg1 = *argp1;
43378   {
43379     try {
43380       result = Dali::Path::DownCast(arg1);
43381     } catch (std::out_of_range& e) {
43382       {
43383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43384       };
43385     } catch (std::exception& e) {
43386       {
43387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43388       };
43389     } catch (Dali::DaliException e) {
43390       {
43391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43392       };
43393     } catch (...) {
43394       {
43395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43396       };
43397     }
43398   }
43399
43400   jresult = new Dali::Path((const Dali::Path &)result);
43401   return jresult;
43402 }
43403
43404
43405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43406   void * jresult ;
43407   Dali::Path *result = 0 ;
43408
43409   {
43410     try {
43411       result = (Dali::Path *)new Dali::Path();
43412     } catch (std::out_of_range& e) {
43413       {
43414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43415       };
43416     } catch (std::exception& e) {
43417       {
43418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43419       };
43420     } catch (Dali::DaliException e) {
43421       {
43422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43423       };
43424     } catch (...) {
43425       {
43426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43427       };
43428     }
43429   }
43430
43431   jresult = (void *)result;
43432   return jresult;
43433 }
43434
43435
43436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43437   Dali::Path *arg1 = (Dali::Path *) 0 ;
43438
43439   arg1 = (Dali::Path *)jarg1;
43440   {
43441     try {
43442       delete arg1;
43443     } catch (std::out_of_range& e) {
43444       {
43445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43446       };
43447     } catch (std::exception& e) {
43448       {
43449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43450       };
43451     } catch (Dali::DaliException e) {
43452       {
43453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43454       };
43455     } catch (...) {
43456       {
43457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43458       };
43459     }
43460   }
43461
43462 }
43463
43464
43465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43466   void * jresult ;
43467   Dali::Path *arg1 = 0 ;
43468   Dali::Path *result = 0 ;
43469
43470   arg1 = (Dali::Path *)jarg1;
43471   if (!arg1) {
43472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43473     return 0;
43474   }
43475   {
43476     try {
43477       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43478     } catch (std::out_of_range& e) {
43479       {
43480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43481       };
43482     } catch (std::exception& e) {
43483       {
43484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43485       };
43486     } catch (Dali::DaliException e) {
43487       {
43488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43489       };
43490     } catch (...) {
43491       {
43492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43493       };
43494     }
43495   }
43496
43497   jresult = (void *)result;
43498   return jresult;
43499 }
43500
43501
43502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43503   void * jresult ;
43504   Dali::Path *arg1 = (Dali::Path *) 0 ;
43505   Dali::Path *arg2 = 0 ;
43506   Dali::Path *result = 0 ;
43507
43508   arg1 = (Dali::Path *)jarg1;
43509   arg2 = (Dali::Path *)jarg2;
43510   if (!arg2) {
43511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43512     return 0;
43513   }
43514   {
43515     try {
43516       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43517     } catch (std::out_of_range& e) {
43518       {
43519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43520       };
43521     } catch (std::exception& e) {
43522       {
43523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43524       };
43525     } catch (Dali::DaliException e) {
43526       {
43527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43528       };
43529     } catch (...) {
43530       {
43531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43532       };
43533     }
43534   }
43535
43536   jresult = (void *)result;
43537   return jresult;
43538 }
43539
43540
43541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43542   Dali::Path *arg1 = (Dali::Path *) 0 ;
43543   Dali::Vector3 *arg2 = 0 ;
43544
43545   arg1 = (Dali::Path *)jarg1;
43546   arg2 = (Dali::Vector3 *)jarg2;
43547   if (!arg2) {
43548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43549     return ;
43550   }
43551   {
43552     try {
43553       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43554     } catch (std::out_of_range& e) {
43555       {
43556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43557       };
43558     } catch (std::exception& e) {
43559       {
43560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43561       };
43562     } catch (Dali::DaliException e) {
43563       {
43564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43565       };
43566     } catch (...) {
43567       {
43568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43569       };
43570     }
43571   }
43572
43573 }
43574
43575
43576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43577   Dali::Path *arg1 = (Dali::Path *) 0 ;
43578   Dali::Vector3 *arg2 = 0 ;
43579
43580   arg1 = (Dali::Path *)jarg1;
43581   arg2 = (Dali::Vector3 *)jarg2;
43582   if (!arg2) {
43583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43584     return ;
43585   }
43586   {
43587     try {
43588       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43589     } catch (std::out_of_range& e) {
43590       {
43591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43592       };
43593     } catch (std::exception& e) {
43594       {
43595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43596       };
43597     } catch (Dali::DaliException e) {
43598       {
43599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43600       };
43601     } catch (...) {
43602       {
43603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43604       };
43605     }
43606   }
43607
43608 }
43609
43610
43611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43612   Dali::Path *arg1 = (Dali::Path *) 0 ;
43613   float arg2 ;
43614
43615   arg1 = (Dali::Path *)jarg1;
43616   arg2 = (float)jarg2;
43617   {
43618     try {
43619       (arg1)->GenerateControlPoints(arg2);
43620     } catch (std::out_of_range& e) {
43621       {
43622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43623       };
43624     } catch (std::exception& e) {
43625       {
43626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43627       };
43628     } catch (Dali::DaliException e) {
43629       {
43630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43631       };
43632     } catch (...) {
43633       {
43634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43635       };
43636     }
43637   }
43638
43639 }
43640
43641
43642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43643   Dali::Path *arg1 = (Dali::Path *) 0 ;
43644   float arg2 ;
43645   Dali::Vector3 *arg3 = 0 ;
43646   Dali::Vector3 *arg4 = 0 ;
43647
43648   arg1 = (Dali::Path *)jarg1;
43649   arg2 = (float)jarg2;
43650   arg3 = (Dali::Vector3 *)jarg3;
43651   if (!arg3) {
43652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43653     return ;
43654   }
43655   arg4 = (Dali::Vector3 *)jarg4;
43656   if (!arg4) {
43657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43658     return ;
43659   }
43660   {
43661     try {
43662       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43663     } catch (std::out_of_range& e) {
43664       {
43665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43666       };
43667     } catch (std::exception& e) {
43668       {
43669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43670       };
43671     } catch (Dali::DaliException e) {
43672       {
43673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43674       };
43675     } catch (...) {
43676       {
43677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43678       };
43679     }
43680   }
43681
43682 }
43683
43684
43685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43686   void * jresult ;
43687   Dali::Path *arg1 = (Dali::Path *) 0 ;
43688   size_t arg2 ;
43689   Dali::Vector3 *result = 0 ;
43690
43691   arg1 = (Dali::Path *)jarg1;
43692   arg2 = (size_t)jarg2;
43693   {
43694     try {
43695       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43696     } catch (std::out_of_range& e) {
43697       {
43698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43699       };
43700     } catch (std::exception& e) {
43701       {
43702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43703       };
43704     } catch (Dali::DaliException e) {
43705       {
43706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43707       };
43708     } catch (...) {
43709       {
43710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43711       };
43712     }
43713   }
43714
43715   jresult = (void *)result;
43716   return jresult;
43717 }
43718
43719
43720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43721   void * jresult ;
43722   Dali::Path *arg1 = (Dali::Path *) 0 ;
43723   size_t arg2 ;
43724   Dali::Vector3 *result = 0 ;
43725
43726   arg1 = (Dali::Path *)jarg1;
43727   arg2 = (size_t)jarg2;
43728   {
43729     try {
43730       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43731     } catch (std::out_of_range& e) {
43732       {
43733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43734       };
43735     } catch (std::exception& e) {
43736       {
43737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43738       };
43739     } catch (Dali::DaliException e) {
43740       {
43741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43742       };
43743     } catch (...) {
43744       {
43745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43746       };
43747     }
43748   }
43749
43750   jresult = (void *)result;
43751   return jresult;
43752 }
43753
43754
43755 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43756   unsigned long jresult ;
43757   Dali::Path *arg1 = (Dali::Path *) 0 ;
43758   size_t result;
43759
43760   arg1 = (Dali::Path *)jarg1;
43761   {
43762     try {
43763       result = ((Dali::Path const *)arg1)->GetPointCount();
43764     } catch (std::out_of_range& e) {
43765       {
43766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43767       };
43768     } catch (std::exception& e) {
43769       {
43770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43771       };
43772     } catch (Dali::DaliException e) {
43773       {
43774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43775       };
43776     } catch (...) {
43777       {
43778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43779       };
43780     }
43781   }
43782
43783   jresult = (unsigned long)result;
43784   return jresult;
43785 }
43786
43787
43788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43789   void * jresult ;
43790   float arg1 ;
43791   Dali::TimePeriod *result = 0 ;
43792
43793   arg1 = (float)jarg1;
43794   {
43795     try {
43796       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43797     } catch (std::out_of_range& e) {
43798       {
43799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43800       };
43801     } catch (std::exception& e) {
43802       {
43803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43804       };
43805     } catch (Dali::DaliException e) {
43806       {
43807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43808       };
43809     } catch (...) {
43810       {
43811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43812       };
43813     }
43814   }
43815
43816   jresult = (void *)result;
43817   return jresult;
43818 }
43819
43820
43821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43822   void * jresult ;
43823   float arg1 ;
43824   float arg2 ;
43825   Dali::TimePeriod *result = 0 ;
43826
43827   arg1 = (float)jarg1;
43828   arg2 = (float)jarg2;
43829   {
43830     try {
43831       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43832     } catch (std::out_of_range& e) {
43833       {
43834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43835       };
43836     } catch (std::exception& e) {
43837       {
43838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43839       };
43840     } catch (Dali::DaliException e) {
43841       {
43842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43843       };
43844     } catch (...) {
43845       {
43846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43847       };
43848     }
43849   }
43850
43851   jresult = (void *)result;
43852   return jresult;
43853 }
43854
43855
43856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43857   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43858
43859   arg1 = (Dali::TimePeriod *)jarg1;
43860   {
43861     try {
43862       delete arg1;
43863     } catch (std::out_of_range& e) {
43864       {
43865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43866       };
43867     } catch (std::exception& e) {
43868       {
43869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43870       };
43871     } catch (Dali::DaliException e) {
43872       {
43873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43874       };
43875     } catch (...) {
43876       {
43877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43878       };
43879     }
43880   }
43881
43882 }
43883
43884
43885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43886   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43887   float arg2 ;
43888
43889   arg1 = (Dali::TimePeriod *)jarg1;
43890   arg2 = (float)jarg2;
43891   if (arg1) (arg1)->delaySeconds = arg2;
43892 }
43893
43894
43895 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43896   float jresult ;
43897   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43898   float result;
43899
43900   arg1 = (Dali::TimePeriod *)jarg1;
43901   result = (float) ((arg1)->delaySeconds);
43902   jresult = result;
43903   return jresult;
43904 }
43905
43906
43907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43908   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43909   float arg2 ;
43910
43911   arg1 = (Dali::TimePeriod *)jarg1;
43912   arg2 = (float)jarg2;
43913   if (arg1) (arg1)->durationSeconds = arg2;
43914 }
43915
43916
43917 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43918   float jresult ;
43919   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43920   float result;
43921
43922   arg1 = (Dali::TimePeriod *)jarg1;
43923   result = (float) ((arg1)->durationSeconds);
43924   jresult = result;
43925   return jresult;
43926 }
43927
43928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43929   int jresult ;
43930   int result;
43931
43932   result = (int)Dali::LinearConstrainer::Property::VALUE;
43933   jresult = (int)result;
43934   return jresult;
43935 }
43936
43937
43938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43939   int jresult ;
43940   int result;
43941
43942   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43943   jresult = (int)result;
43944   return jresult;
43945 }
43946
43947
43948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43949   void * jresult ;
43950   Dali::LinearConstrainer::Property *result = 0 ;
43951
43952   {
43953     try {
43954       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43955     } catch (std::out_of_range& e) {
43956       {
43957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43958       };
43959     } catch (std::exception& e) {
43960       {
43961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43962       };
43963     } catch (Dali::DaliException e) {
43964       {
43965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43966       };
43967     } catch (...) {
43968       {
43969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43970       };
43971     }
43972   }
43973
43974   jresult = (void *)result;
43975   return jresult;
43976 }
43977
43978
43979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43980   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43981
43982   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43983   {
43984     try {
43985       delete arg1;
43986     } catch (std::out_of_range& e) {
43987       {
43988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43989       };
43990     } catch (std::exception& e) {
43991       {
43992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43993       };
43994     } catch (Dali::DaliException e) {
43995       {
43996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43997       };
43998     } catch (...) {
43999       {
44000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44001       };
44002     }
44003   }
44004
44005 }
44006
44007
44008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44009   void * jresult ;
44010   Dali::LinearConstrainer result;
44011
44012   {
44013     try {
44014       result = Dali::LinearConstrainer::New();
44015     } catch (std::out_of_range& e) {
44016       {
44017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44018       };
44019     } catch (std::exception& e) {
44020       {
44021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44022       };
44023     } catch (Dali::DaliException e) {
44024       {
44025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44026       };
44027     } catch (...) {
44028       {
44029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44030       };
44031     }
44032   }
44033
44034   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44035   return jresult;
44036 }
44037
44038
44039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44040   void * jresult ;
44041   Dali::BaseHandle arg1 ;
44042   Dali::BaseHandle *argp1 ;
44043   Dali::LinearConstrainer result;
44044
44045   argp1 = (Dali::BaseHandle *)jarg1;
44046   if (!argp1) {
44047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44048     return 0;
44049   }
44050   arg1 = *argp1;
44051   {
44052     try {
44053       result = Dali::LinearConstrainer::DownCast(arg1);
44054     } catch (std::out_of_range& e) {
44055       {
44056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44057       };
44058     } catch (std::exception& e) {
44059       {
44060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44061       };
44062     } catch (Dali::DaliException e) {
44063       {
44064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44065       };
44066     } catch (...) {
44067       {
44068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44069       };
44070     }
44071   }
44072
44073   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44074   return jresult;
44075 }
44076
44077
44078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44079   void * jresult ;
44080   Dali::LinearConstrainer *result = 0 ;
44081
44082   {
44083     try {
44084       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44085     } catch (std::out_of_range& e) {
44086       {
44087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44088       };
44089     } catch (std::exception& e) {
44090       {
44091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44092       };
44093     } catch (Dali::DaliException e) {
44094       {
44095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44096       };
44097     } catch (...) {
44098       {
44099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44100       };
44101     }
44102   }
44103
44104   jresult = (void *)result;
44105   return jresult;
44106 }
44107
44108
44109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44110   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44111
44112   arg1 = (Dali::LinearConstrainer *)jarg1;
44113   {
44114     try {
44115       delete arg1;
44116     } catch (std::out_of_range& e) {
44117       {
44118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44119       };
44120     } catch (std::exception& e) {
44121       {
44122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44123       };
44124     } catch (Dali::DaliException e) {
44125       {
44126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44127       };
44128     } catch (...) {
44129       {
44130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44131       };
44132     }
44133   }
44134
44135 }
44136
44137
44138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44139   void * jresult ;
44140   Dali::LinearConstrainer *arg1 = 0 ;
44141   Dali::LinearConstrainer *result = 0 ;
44142
44143   arg1 = (Dali::LinearConstrainer *)jarg1;
44144   if (!arg1) {
44145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44146     return 0;
44147   }
44148   {
44149     try {
44150       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44151     } catch (std::out_of_range& e) {
44152       {
44153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44154       };
44155     } catch (std::exception& e) {
44156       {
44157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44158       };
44159     } catch (Dali::DaliException e) {
44160       {
44161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44162       };
44163     } catch (...) {
44164       {
44165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44166       };
44167     }
44168   }
44169
44170   jresult = (void *)result;
44171   return jresult;
44172 }
44173
44174
44175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44176   void * jresult ;
44177   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44178   Dali::LinearConstrainer *arg2 = 0 ;
44179   Dali::LinearConstrainer *result = 0 ;
44180
44181   arg1 = (Dali::LinearConstrainer *)jarg1;
44182   arg2 = (Dali::LinearConstrainer *)jarg2;
44183   if (!arg2) {
44184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44185     return 0;
44186   }
44187   {
44188     try {
44189       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44190     } catch (std::out_of_range& e) {
44191       {
44192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44193       };
44194     } catch (std::exception& e) {
44195       {
44196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44197       };
44198     } catch (Dali::DaliException e) {
44199       {
44200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44201       };
44202     } catch (...) {
44203       {
44204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44205       };
44206     }
44207   }
44208
44209   jresult = (void *)result;
44210   return jresult;
44211 }
44212
44213
44214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44215   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44216   SwigValueWrapper< Dali::Property > arg2 ;
44217   SwigValueWrapper< Dali::Property > arg3 ;
44218   Dali::Vector2 *arg4 = 0 ;
44219   Dali::Vector2 *arg5 = 0 ;
44220   Dali::Property *argp2 ;
44221   Dali::Property *argp3 ;
44222
44223   arg1 = (Dali::LinearConstrainer *)jarg1;
44224   argp2 = (Dali::Property *)jarg2;
44225   if (!argp2) {
44226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44227     return ;
44228   }
44229   arg2 = *argp2;
44230   argp3 = (Dali::Property *)jarg3;
44231   if (!argp3) {
44232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44233     return ;
44234   }
44235   arg3 = *argp3;
44236   arg4 = (Dali::Vector2 *)jarg4;
44237   if (!arg4) {
44238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44239     return ;
44240   }
44241   arg5 = (Dali::Vector2 *)jarg5;
44242   if (!arg5) {
44243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44244     return ;
44245   }
44246   {
44247     try {
44248       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44249     } catch (std::out_of_range& e) {
44250       {
44251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44252       };
44253     } catch (std::exception& e) {
44254       {
44255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44256       };
44257     } catch (Dali::DaliException e) {
44258       {
44259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44260       };
44261     } catch (...) {
44262       {
44263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44264       };
44265     }
44266   }
44267
44268 }
44269
44270
44271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44272   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44273   SwigValueWrapper< Dali::Property > arg2 ;
44274   SwigValueWrapper< Dali::Property > arg3 ;
44275   Dali::Vector2 *arg4 = 0 ;
44276   Dali::Property *argp2 ;
44277   Dali::Property *argp3 ;
44278
44279   arg1 = (Dali::LinearConstrainer *)jarg1;
44280   argp2 = (Dali::Property *)jarg2;
44281   if (!argp2) {
44282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44283     return ;
44284   }
44285   arg2 = *argp2;
44286   argp3 = (Dali::Property *)jarg3;
44287   if (!argp3) {
44288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44289     return ;
44290   }
44291   arg3 = *argp3;
44292   arg4 = (Dali::Vector2 *)jarg4;
44293   if (!arg4) {
44294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44295     return ;
44296   }
44297   {
44298     try {
44299       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44300     } catch (std::out_of_range& e) {
44301       {
44302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44303       };
44304     } catch (std::exception& e) {
44305       {
44306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44307       };
44308     } catch (Dali::DaliException e) {
44309       {
44310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44311       };
44312     } catch (...) {
44313       {
44314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44315       };
44316     }
44317   }
44318
44319 }
44320
44321
44322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44323   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44324   Dali::Handle *arg2 = 0 ;
44325
44326   arg1 = (Dali::LinearConstrainer *)jarg1;
44327   arg2 = (Dali::Handle *)jarg2;
44328   if (!arg2) {
44329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44330     return ;
44331   }
44332   {
44333     try {
44334       (arg1)->Remove(*arg2);
44335     } catch (std::out_of_range& e) {
44336       {
44337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44338       };
44339     } catch (std::exception& e) {
44340       {
44341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44342       };
44343     } catch (Dali::DaliException e) {
44344       {
44345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44346       };
44347     } catch (...) {
44348       {
44349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44350       };
44351     }
44352   }
44353
44354 }
44355
44356
44357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44358   int jresult ;
44359   int result;
44360
44361   result = (int)Dali::PathConstrainer::Property::FORWARD;
44362   jresult = (int)result;
44363   return jresult;
44364 }
44365
44366
44367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44368   int jresult ;
44369   int result;
44370
44371   result = (int)Dali::PathConstrainer::Property::POINTS;
44372   jresult = (int)result;
44373   return jresult;
44374 }
44375
44376
44377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44378   int jresult ;
44379   int result;
44380
44381   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44382   jresult = (int)result;
44383   return jresult;
44384 }
44385
44386
44387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44388   void * jresult ;
44389   Dali::PathConstrainer::Property *result = 0 ;
44390
44391   {
44392     try {
44393       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44394     } catch (std::out_of_range& e) {
44395       {
44396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44397       };
44398     } catch (std::exception& e) {
44399       {
44400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44401       };
44402     } catch (Dali::DaliException e) {
44403       {
44404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44405       };
44406     } catch (...) {
44407       {
44408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44409       };
44410     }
44411   }
44412
44413   jresult = (void *)result;
44414   return jresult;
44415 }
44416
44417
44418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44419   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44420
44421   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44422   {
44423     try {
44424       delete arg1;
44425     } catch (std::out_of_range& e) {
44426       {
44427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44428       };
44429     } catch (std::exception& e) {
44430       {
44431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44432       };
44433     } catch (Dali::DaliException e) {
44434       {
44435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44436       };
44437     } catch (...) {
44438       {
44439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44440       };
44441     }
44442   }
44443
44444 }
44445
44446
44447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44448   void * jresult ;
44449   Dali::PathConstrainer result;
44450
44451   {
44452     try {
44453       result = Dali::PathConstrainer::New();
44454     } catch (std::out_of_range& e) {
44455       {
44456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44457       };
44458     } catch (std::exception& e) {
44459       {
44460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44461       };
44462     } catch (Dali::DaliException e) {
44463       {
44464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44465       };
44466     } catch (...) {
44467       {
44468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44469       };
44470     }
44471   }
44472
44473   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44474   return jresult;
44475 }
44476
44477
44478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44479   void * jresult ;
44480   Dali::BaseHandle arg1 ;
44481   Dali::BaseHandle *argp1 ;
44482   Dali::PathConstrainer result;
44483
44484   argp1 = (Dali::BaseHandle *)jarg1;
44485   if (!argp1) {
44486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44487     return 0;
44488   }
44489   arg1 = *argp1;
44490   {
44491     try {
44492       result = Dali::PathConstrainer::DownCast(arg1);
44493     } catch (std::out_of_range& e) {
44494       {
44495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44496       };
44497     } catch (std::exception& e) {
44498       {
44499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44500       };
44501     } catch (Dali::DaliException e) {
44502       {
44503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44504       };
44505     } catch (...) {
44506       {
44507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44508       };
44509     }
44510   }
44511
44512   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44513   return jresult;
44514 }
44515
44516
44517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44518   void * jresult ;
44519   Dali::PathConstrainer *result = 0 ;
44520
44521   {
44522     try {
44523       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44524     } catch (std::out_of_range& e) {
44525       {
44526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44527       };
44528     } catch (std::exception& e) {
44529       {
44530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44531       };
44532     } catch (Dali::DaliException e) {
44533       {
44534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44535       };
44536     } catch (...) {
44537       {
44538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44539       };
44540     }
44541   }
44542
44543   jresult = (void *)result;
44544   return jresult;
44545 }
44546
44547
44548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44549   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44550
44551   arg1 = (Dali::PathConstrainer *)jarg1;
44552   {
44553     try {
44554       delete arg1;
44555     } catch (std::out_of_range& e) {
44556       {
44557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44558       };
44559     } catch (std::exception& e) {
44560       {
44561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44562       };
44563     } catch (Dali::DaliException e) {
44564       {
44565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44566       };
44567     } catch (...) {
44568       {
44569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44570       };
44571     }
44572   }
44573
44574 }
44575
44576
44577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44578   void * jresult ;
44579   Dali::PathConstrainer *arg1 = 0 ;
44580   Dali::PathConstrainer *result = 0 ;
44581
44582   arg1 = (Dali::PathConstrainer *)jarg1;
44583   if (!arg1) {
44584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44585     return 0;
44586   }
44587   {
44588     try {
44589       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44590     } catch (std::out_of_range& e) {
44591       {
44592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44593       };
44594     } catch (std::exception& e) {
44595       {
44596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44597       };
44598     } catch (Dali::DaliException e) {
44599       {
44600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44601       };
44602     } catch (...) {
44603       {
44604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44605       };
44606     }
44607   }
44608
44609   jresult = (void *)result;
44610   return jresult;
44611 }
44612
44613
44614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44615   void * jresult ;
44616   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44617   Dali::PathConstrainer *arg2 = 0 ;
44618   Dali::PathConstrainer *result = 0 ;
44619
44620   arg1 = (Dali::PathConstrainer *)jarg1;
44621   arg2 = (Dali::PathConstrainer *)jarg2;
44622   if (!arg2) {
44623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44624     return 0;
44625   }
44626   {
44627     try {
44628       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44629     } catch (std::out_of_range& e) {
44630       {
44631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44632       };
44633     } catch (std::exception& e) {
44634       {
44635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44636       };
44637     } catch (Dali::DaliException e) {
44638       {
44639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44640       };
44641     } catch (...) {
44642       {
44643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44644       };
44645     }
44646   }
44647
44648   jresult = (void *)result;
44649   return jresult;
44650 }
44651
44652
44653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44654   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44655   SwigValueWrapper< Dali::Property > arg2 ;
44656   SwigValueWrapper< Dali::Property > arg3 ;
44657   Dali::Vector2 *arg4 = 0 ;
44658   Dali::Vector2 *arg5 = 0 ;
44659   Dali::Property *argp2 ;
44660   Dali::Property *argp3 ;
44661
44662   arg1 = (Dali::PathConstrainer *)jarg1;
44663   argp2 = (Dali::Property *)jarg2;
44664   if (!argp2) {
44665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44666     return ;
44667   }
44668   arg2 = *argp2;
44669   argp3 = (Dali::Property *)jarg3;
44670   if (!argp3) {
44671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44672     return ;
44673   }
44674   arg3 = *argp3;
44675   arg4 = (Dali::Vector2 *)jarg4;
44676   if (!arg4) {
44677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44678     return ;
44679   }
44680   arg5 = (Dali::Vector2 *)jarg5;
44681   if (!arg5) {
44682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44683     return ;
44684   }
44685   {
44686     try {
44687       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44688     } catch (std::out_of_range& e) {
44689       {
44690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44691       };
44692     } catch (std::exception& e) {
44693       {
44694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44695       };
44696     } catch (Dali::DaliException e) {
44697       {
44698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44699       };
44700     } catch (...) {
44701       {
44702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44703       };
44704     }
44705   }
44706
44707 }
44708
44709
44710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44711   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44712   SwigValueWrapper< Dali::Property > arg2 ;
44713   SwigValueWrapper< Dali::Property > arg3 ;
44714   Dali::Vector2 *arg4 = 0 ;
44715   Dali::Property *argp2 ;
44716   Dali::Property *argp3 ;
44717
44718   arg1 = (Dali::PathConstrainer *)jarg1;
44719   argp2 = (Dali::Property *)jarg2;
44720   if (!argp2) {
44721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44722     return ;
44723   }
44724   arg2 = *argp2;
44725   argp3 = (Dali::Property *)jarg3;
44726   if (!argp3) {
44727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44728     return ;
44729   }
44730   arg3 = *argp3;
44731   arg4 = (Dali::Vector2 *)jarg4;
44732   if (!arg4) {
44733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44734     return ;
44735   }
44736   {
44737     try {
44738       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44739     } catch (std::out_of_range& e) {
44740       {
44741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44742       };
44743     } catch (std::exception& e) {
44744       {
44745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44746       };
44747     } catch (Dali::DaliException e) {
44748       {
44749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44750       };
44751     } catch (...) {
44752       {
44753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44754       };
44755     }
44756   }
44757
44758 }
44759
44760
44761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44762   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44763   Dali::Handle *arg2 = 0 ;
44764
44765   arg1 = (Dali::PathConstrainer *)jarg1;
44766   arg2 = (Dali::Handle *)jarg2;
44767   if (!arg2) {
44768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44769     return ;
44770   }
44771   {
44772     try {
44773       (arg1)->Remove(*arg2);
44774     } catch (std::out_of_range& e) {
44775       {
44776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44777       };
44778     } catch (std::exception& e) {
44779       {
44780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44781       };
44782     } catch (Dali::DaliException e) {
44783       {
44784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44785       };
44786     } catch (...) {
44787       {
44788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44789       };
44790     }
44791   }
44792
44793 }
44794
44795
44796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44797   int jresult ;
44798   Dali::FittingMode::Type result;
44799
44800   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44801   jresult = (int)result;
44802   return jresult;
44803 }
44804
44805
44806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44807   int jresult ;
44808   Dali::SamplingMode::Type result;
44809
44810   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44811   jresult = (int)result;
44812   return jresult;
44813 }
44814
44815
44816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
44817   unsigned int jresult ;
44818   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44819   bool result;
44820
44821   arg1 = (Dali::NativeImageInterface *)jarg1;
44822   {
44823     try {
44824       result = (bool)(arg1)->GlExtensionCreate();
44825     } catch (std::out_of_range& e) {
44826       {
44827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44828       };
44829     } catch (std::exception& e) {
44830       {
44831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44832       };
44833     } catch (Dali::DaliException e) {
44834       {
44835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44836       };
44837     } catch (...) {
44838       {
44839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44840       };
44841     }
44842   }
44843
44844   jresult = result;
44845   return jresult;
44846 }
44847
44848
44849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
44850   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44851
44852   arg1 = (Dali::NativeImageInterface *)jarg1;
44853   {
44854     try {
44855       (arg1)->GlExtensionDestroy();
44856     } catch (std::out_of_range& e) {
44857       {
44858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44859       };
44860     } catch (std::exception& e) {
44861       {
44862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44863       };
44864     } catch (Dali::DaliException e) {
44865       {
44866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44867       };
44868     } catch (...) {
44869       {
44870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44871       };
44872     }
44873   }
44874
44875 }
44876
44877
44878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
44879   unsigned int jresult ;
44880   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44881   unsigned int result;
44882
44883   arg1 = (Dali::NativeImageInterface *)jarg1;
44884   {
44885     try {
44886       result = (unsigned int)(arg1)->TargetTexture();
44887     } catch (std::out_of_range& e) {
44888       {
44889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44890       };
44891     } catch (std::exception& e) {
44892       {
44893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44894       };
44895     } catch (Dali::DaliException e) {
44896       {
44897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44898       };
44899     } catch (...) {
44900       {
44901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44902       };
44903     }
44904   }
44905
44906   jresult = result;
44907   return jresult;
44908 }
44909
44910
44911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
44912   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44913
44914   arg1 = (Dali::NativeImageInterface *)jarg1;
44915   {
44916     try {
44917       (arg1)->PrepareTexture();
44918     } catch (std::out_of_range& e) {
44919       {
44920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44921       };
44922     } catch (std::exception& e) {
44923       {
44924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44925       };
44926     } catch (Dali::DaliException e) {
44927       {
44928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44929       };
44930     } catch (...) {
44931       {
44932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44933       };
44934     }
44935   }
44936
44937 }
44938
44939
44940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
44941   unsigned int jresult ;
44942   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44943   unsigned int result;
44944
44945   arg1 = (Dali::NativeImageInterface *)jarg1;
44946   {
44947     try {
44948       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
44949     } catch (std::out_of_range& e) {
44950       {
44951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44952       };
44953     } catch (std::exception& e) {
44954       {
44955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44956       };
44957     } catch (Dali::DaliException e) {
44958       {
44959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44960       };
44961     } catch (...) {
44962       {
44963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44964       };
44965     }
44966   }
44967
44968   jresult = result;
44969   return jresult;
44970 }
44971
44972
44973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
44974   unsigned int jresult ;
44975   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44976   unsigned int result;
44977
44978   arg1 = (Dali::NativeImageInterface *)jarg1;
44979   {
44980     try {
44981       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
44982     } catch (std::out_of_range& e) {
44983       {
44984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44985       };
44986     } catch (std::exception& e) {
44987       {
44988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44989       };
44990     } catch (Dali::DaliException e) {
44991       {
44992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44993       };
44994     } catch (...) {
44995       {
44996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44997       };
44998     }
44999   }
45000
45001   jresult = result;
45002   return jresult;
45003 }
45004
45005
45006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
45007   unsigned int jresult ;
45008   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
45009   bool result;
45010
45011   arg1 = (Dali::NativeImageInterface *)jarg1;
45012   {
45013     try {
45014       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
45015     } catch (std::out_of_range& e) {
45016       {
45017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45018       };
45019     } catch (std::exception& e) {
45020       {
45021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45022       };
45023     } catch (Dali::DaliException e) {
45024       {
45025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45026       };
45027     } catch (...) {
45028       {
45029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45030       };
45031     }
45032   }
45033
45034   jresult = result;
45035   return jresult;
45036 }
45037
45038
45039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
45040   void * jresult ;
45041   std::string *arg1 = 0 ;
45042   Dali::ImageDimensions result;
45043
45044   if (!jarg1) {
45045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45046     return 0;
45047   }
45048   std::string arg1_str(jarg1);
45049   arg1 = &arg1_str;
45050   {
45051     try {
45052       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
45053     } catch (std::out_of_range& e) {
45054       {
45055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45056       };
45057     } catch (std::exception& e) {
45058       {
45059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45060       };
45061     } catch (Dali::DaliException e) {
45062       {
45063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45064       };
45065     } catch (...) {
45066       {
45067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45068       };
45069     }
45070   }
45071
45072   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
45073
45074   //argout typemap for const std::string&
45075
45076   return jresult;
45077 }
45078
45079
45080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
45081   void * jresult ;
45082   Dali::ResourceImage *result = 0 ;
45083
45084   {
45085     try {
45086       result = (Dali::ResourceImage *)new Dali::ResourceImage();
45087     } catch (std::out_of_range& e) {
45088       {
45089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45090       };
45091     } catch (std::exception& e) {
45092       {
45093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45094       };
45095     } catch (Dali::DaliException e) {
45096       {
45097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45098       };
45099     } catch (...) {
45100       {
45101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45102       };
45103     }
45104   }
45105
45106   jresult = (void *)result;
45107   return jresult;
45108 }
45109
45110
45111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
45112   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
45113
45114   arg1 = (Dali::ResourceImage *)jarg1;
45115   {
45116     try {
45117       delete arg1;
45118     } catch (std::out_of_range& e) {
45119       {
45120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45121       };
45122     } catch (std::exception& e) {
45123       {
45124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45125       };
45126     } catch (Dali::DaliException e) {
45127       {
45128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45129       };
45130     } catch (...) {
45131       {
45132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45133       };
45134     }
45135   }
45136
45137 }
45138
45139
45140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
45141   void * jresult ;
45142   Dali::ResourceImage *arg1 = 0 ;
45143   Dali::ResourceImage *result = 0 ;
45144
45145   arg1 = (Dali::ResourceImage *)jarg1;
45146   if (!arg1) {
45147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
45148     return 0;
45149   }
45150   {
45151     try {
45152       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
45153     } catch (std::out_of_range& e) {
45154       {
45155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45156       };
45157     } catch (std::exception& e) {
45158       {
45159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45160       };
45161     } catch (Dali::DaliException e) {
45162       {
45163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45164       };
45165     } catch (...) {
45166       {
45167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45168       };
45169     }
45170   }
45171
45172   jresult = (void *)result;
45173   return jresult;
45174 }
45175
45176
45177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
45178   void * jresult ;
45179   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
45180   Dali::ResourceImage *arg2 = 0 ;
45181   Dali::ResourceImage *result = 0 ;
45182
45183   arg1 = (Dali::ResourceImage *)jarg1;
45184   arg2 = (Dali::ResourceImage *)jarg2;
45185   if (!arg2) {
45186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
45187     return 0;
45188   }
45189   {
45190     try {
45191       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
45192     } catch (std::out_of_range& e) {
45193       {
45194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45195       };
45196     } catch (std::exception& e) {
45197       {
45198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45199       };
45200     } catch (Dali::DaliException e) {
45201       {
45202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45203       };
45204     } catch (...) {
45205       {
45206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45207       };
45208     }
45209   }
45210
45211   jresult = (void *)result;
45212   return jresult;
45213 }
45214
45215
45216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
45217   void * jresult ;
45218   std::string *arg1 = 0 ;
45219   bool arg2 ;
45220   Dali::ResourceImage result;
45221
45222   if (!jarg1) {
45223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45224     return 0;
45225   }
45226   std::string arg1_str(jarg1);
45227   arg1 = &arg1_str;
45228   arg2 = jarg2 ? true : false;
45229   {
45230     try {
45231       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
45232     } catch (std::out_of_range& e) {
45233       {
45234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45235       };
45236     } catch (std::exception& e) {
45237       {
45238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45239       };
45240     } catch (Dali::DaliException e) {
45241       {
45242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45243       };
45244     } catch (...) {
45245       {
45246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45247       };
45248     }
45249   }
45250
45251   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45252
45253   //argout typemap for const std::string&
45254
45255   return jresult;
45256 }
45257
45258
45259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
45260   void * jresult ;
45261   std::string *arg1 = 0 ;
45262   Dali::ResourceImage result;
45263
45264   if (!jarg1) {
45265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45266     return 0;
45267   }
45268   std::string arg1_str(jarg1);
45269   arg1 = &arg1_str;
45270   {
45271     try {
45272       result = Dali::ResourceImage::New((std::string const &)*arg1);
45273     } catch (std::out_of_range& e) {
45274       {
45275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45276       };
45277     } catch (std::exception& e) {
45278       {
45279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45280       };
45281     } catch (Dali::DaliException e) {
45282       {
45283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45284       };
45285     } catch (...) {
45286       {
45287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45288       };
45289     }
45290   }
45291
45292   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45293
45294   //argout typemap for const std::string&
45295
45296   return jresult;
45297 }
45298
45299
45300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
45301   void * jresult ;
45302   std::string *arg1 = 0 ;
45303   Dali::ImageDimensions arg2 ;
45304   Dali::FittingMode::Type arg3 ;
45305   Dali::SamplingMode::Type arg4 ;
45306   bool arg5 ;
45307   Dali::ImageDimensions *argp2 ;
45308   Dali::ResourceImage result;
45309
45310   if (!jarg1) {
45311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45312     return 0;
45313   }
45314   std::string arg1_str(jarg1);
45315   arg1 = &arg1_str;
45316   argp2 = (Dali::ImageDimensions *)jarg2;
45317   if (!argp2) {
45318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45319     return 0;
45320   }
45321   arg2 = *argp2;
45322   arg3 = (Dali::FittingMode::Type)jarg3;
45323   arg4 = (Dali::SamplingMode::Type)jarg4;
45324   arg5 = jarg5 ? true : false;
45325   {
45326     try {
45327       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
45328     } catch (std::out_of_range& e) {
45329       {
45330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45331       };
45332     } catch (std::exception& e) {
45333       {
45334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45335       };
45336     } catch (Dali::DaliException e) {
45337       {
45338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45339       };
45340     } catch (...) {
45341       {
45342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45343       };
45344     }
45345   }
45346
45347   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45348
45349   //argout typemap for const std::string&
45350
45351   return jresult;
45352 }
45353
45354
45355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
45356   void * jresult ;
45357   std::string *arg1 = 0 ;
45358   Dali::ImageDimensions arg2 ;
45359   Dali::FittingMode::Type arg3 ;
45360   Dali::SamplingMode::Type arg4 ;
45361   Dali::ImageDimensions *argp2 ;
45362   Dali::ResourceImage result;
45363
45364   if (!jarg1) {
45365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45366     return 0;
45367   }
45368   std::string arg1_str(jarg1);
45369   arg1 = &arg1_str;
45370   argp2 = (Dali::ImageDimensions *)jarg2;
45371   if (!argp2) {
45372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45373     return 0;
45374   }
45375   arg2 = *argp2;
45376   arg3 = (Dali::FittingMode::Type)jarg3;
45377   arg4 = (Dali::SamplingMode::Type)jarg4;
45378   {
45379     try {
45380       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
45381     } catch (std::out_of_range& e) {
45382       {
45383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45384       };
45385     } catch (std::exception& e) {
45386       {
45387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45388       };
45389     } catch (Dali::DaliException e) {
45390       {
45391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45392       };
45393     } catch (...) {
45394       {
45395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45396       };
45397     }
45398   }
45399
45400   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45401
45402   //argout typemap for const std::string&
45403
45404   return jresult;
45405 }
45406
45407
45408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
45409   void * jresult ;
45410   std::string *arg1 = 0 ;
45411   Dali::ImageDimensions arg2 ;
45412   Dali::FittingMode::Type arg3 ;
45413   Dali::ImageDimensions *argp2 ;
45414   Dali::ResourceImage result;
45415
45416   if (!jarg1) {
45417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45418     return 0;
45419   }
45420   std::string arg1_str(jarg1);
45421   arg1 = &arg1_str;
45422   argp2 = (Dali::ImageDimensions *)jarg2;
45423   if (!argp2) {
45424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45425     return 0;
45426   }
45427   arg2 = *argp2;
45428   arg3 = (Dali::FittingMode::Type)jarg3;
45429   {
45430     try {
45431       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
45432     } catch (std::out_of_range& e) {
45433       {
45434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45435       };
45436     } catch (std::exception& e) {
45437       {
45438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45439       };
45440     } catch (Dali::DaliException e) {
45441       {
45442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45443       };
45444     } catch (...) {
45445       {
45446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45447       };
45448     }
45449   }
45450
45451   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45452
45453   //argout typemap for const std::string&
45454
45455   return jresult;
45456 }
45457
45458
45459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
45460   void * jresult ;
45461   std::string *arg1 = 0 ;
45462   Dali::ImageDimensions arg2 ;
45463   Dali::ImageDimensions *argp2 ;
45464   Dali::ResourceImage result;
45465
45466   if (!jarg1) {
45467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45468     return 0;
45469   }
45470   std::string arg1_str(jarg1);
45471   arg1 = &arg1_str;
45472   argp2 = (Dali::ImageDimensions *)jarg2;
45473   if (!argp2) {
45474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45475     return 0;
45476   }
45477   arg2 = *argp2;
45478   {
45479     try {
45480       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
45481     } catch (std::out_of_range& e) {
45482       {
45483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45484       };
45485     } catch (std::exception& e) {
45486       {
45487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45488       };
45489     } catch (Dali::DaliException e) {
45490       {
45491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45492       };
45493     } catch (...) {
45494       {
45495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45496       };
45497     }
45498   }
45499
45500   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45501
45502   //argout typemap for const std::string&
45503
45504   return jresult;
45505 }
45506
45507
45508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
45509   void * jresult ;
45510   Dali::BaseHandle arg1 ;
45511   Dali::BaseHandle *argp1 ;
45512   Dali::ResourceImage result;
45513
45514   argp1 = (Dali::BaseHandle *)jarg1;
45515   if (!argp1) {
45516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45517     return 0;
45518   }
45519   arg1 = *argp1;
45520   {
45521     try {
45522       result = Dali::ResourceImage::DownCast(arg1);
45523     } catch (std::out_of_range& e) {
45524       {
45525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45526       };
45527     } catch (std::exception& e) {
45528       {
45529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45530       };
45531     } catch (Dali::DaliException e) {
45532       {
45533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45534       };
45535     } catch (...) {
45536       {
45537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45538       };
45539     }
45540   }
45541
45542   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45543   return jresult;
45544 }
45545
45546
45547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
45548   int jresult ;
45549   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
45550   Dali::LoadingState result;
45551
45552   arg1 = (Dali::ResourceImage *)jarg1;
45553   {
45554     try {
45555       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
45556     } catch (std::out_of_range& e) {
45557       {
45558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45559       };
45560     } catch (std::exception& e) {
45561       {
45562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45563       };
45564     } catch (Dali::DaliException e) {
45565       {
45566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45567       };
45568     } catch (...) {
45569       {
45570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45571       };
45572     }
45573   }
45574
45575   jresult = (int)result;
45576   return jresult;
45577 }
45578
45579
45580 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
45581   char * jresult ;
45582   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
45583   std::string result;
45584
45585   arg1 = (Dali::ResourceImage *)jarg1;
45586   {
45587     try {
45588       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
45589     } catch (std::out_of_range& e) {
45590       {
45591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45592       };
45593     } catch (std::exception& e) {
45594       {
45595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45596       };
45597     } catch (Dali::DaliException e) {
45598       {
45599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45600       };
45601     } catch (...) {
45602       {
45603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45604       };
45605     }
45606   }
45607
45608   jresult = SWIG_csharp_string_callback((&result)->c_str());
45609   return jresult;
45610 }
45611
45612
45613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
45614   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
45615
45616   arg1 = (Dali::ResourceImage *)jarg1;
45617   {
45618     try {
45619       (arg1)->Reload();
45620     } catch (std::out_of_range& e) {
45621       {
45622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45623       };
45624     } catch (std::exception& e) {
45625       {
45626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45627       };
45628     } catch (Dali::DaliException e) {
45629       {
45630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45631       };
45632     } catch (...) {
45633       {
45634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45635       };
45636     }
45637   }
45638
45639 }
45640
45641
45642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
45643   void * jresult ;
45644   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
45645   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
45646
45647   arg1 = (Dali::ResourceImage *)jarg1;
45648   {
45649     try {
45650       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
45651     } catch (std::out_of_range& e) {
45652       {
45653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45654       };
45655     } catch (std::exception& e) {
45656       {
45657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45658       };
45659     } catch (Dali::DaliException e) {
45660       {
45661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45662       };
45663     } catch (...) {
45664       {
45665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45666       };
45667     }
45668   }
45669
45670   jresult = (void *)result;
45671   return jresult;
45672 }
45673
45674
45675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
45676   int jresult ;
45677   int result;
45678
45679   result = (int)Dali::CameraActor::Property::TYPE;
45680   jresult = (int)result;
45681   return jresult;
45682 }
45683
45684
45685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
45686   int jresult ;
45687   int result;
45688
45689   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
45690   jresult = (int)result;
45691   return jresult;
45692 }
45693
45694
45695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
45696   int jresult ;
45697   int result;
45698
45699   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
45700   jresult = (int)result;
45701   return jresult;
45702 }
45703
45704
45705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
45706   int jresult ;
45707   int result;
45708
45709   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
45710   jresult = (int)result;
45711   return jresult;
45712 }
45713
45714
45715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
45716   int jresult ;
45717   int result;
45718
45719   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
45720   jresult = (int)result;
45721   return jresult;
45722 }
45723
45724
45725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
45726   int jresult ;
45727   int result;
45728
45729   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
45730   jresult = (int)result;
45731   return jresult;
45732 }
45733
45734
45735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
45736   int jresult ;
45737   int result;
45738
45739   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
45740   jresult = (int)result;
45741   return jresult;
45742 }
45743
45744
45745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
45746   int jresult ;
45747   int result;
45748
45749   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
45750   jresult = (int)result;
45751   return jresult;
45752 }
45753
45754
45755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
45756   int jresult ;
45757   int result;
45758
45759   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
45760   jresult = (int)result;
45761   return jresult;
45762 }
45763
45764
45765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
45766   int jresult ;
45767   int result;
45768
45769   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
45770   jresult = (int)result;
45771   return jresult;
45772 }
45773
45774
45775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
45776   int jresult ;
45777   int result;
45778
45779   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
45780   jresult = (int)result;
45781   return jresult;
45782 }
45783
45784
45785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
45786   int jresult ;
45787   int result;
45788
45789   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
45790   jresult = (int)result;
45791   return jresult;
45792 }
45793
45794
45795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
45796   int jresult ;
45797   int result;
45798
45799   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
45800   jresult = (int)result;
45801   return jresult;
45802 }
45803
45804
45805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
45806   int jresult ;
45807   int result;
45808
45809   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
45810   jresult = (int)result;
45811   return jresult;
45812 }
45813
45814
45815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
45816   void * jresult ;
45817   Dali::CameraActor::Property *result = 0 ;
45818
45819   {
45820     try {
45821       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
45822     } catch (std::out_of_range& e) {
45823       {
45824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45825       };
45826     } catch (std::exception& e) {
45827       {
45828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45829       };
45830     } catch (Dali::DaliException e) {
45831       {
45832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45833       };
45834     } catch (...) {
45835       {
45836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45837       };
45838     }
45839   }
45840
45841   jresult = (void *)result;
45842   return jresult;
45843 }
45844
45845
45846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
45847   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
45848
45849   arg1 = (Dali::CameraActor::Property *)jarg1;
45850   {
45851     try {
45852       delete arg1;
45853     } catch (std::out_of_range& e) {
45854       {
45855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45856       };
45857     } catch (std::exception& e) {
45858       {
45859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45860       };
45861     } catch (Dali::DaliException e) {
45862       {
45863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45864       };
45865     } catch (...) {
45866       {
45867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45868       };
45869     }
45870   }
45871
45872 }
45873
45874
45875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
45876   void * jresult ;
45877   Dali::CameraActor *result = 0 ;
45878
45879   {
45880     try {
45881       result = (Dali::CameraActor *)new Dali::CameraActor();
45882     } catch (std::out_of_range& e) {
45883       {
45884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45885       };
45886     } catch (std::exception& e) {
45887       {
45888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45889       };
45890     } catch (Dali::DaliException e) {
45891       {
45892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45893       };
45894     } catch (...) {
45895       {
45896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45897       };
45898     }
45899   }
45900
45901   jresult = (void *)result;
45902   return jresult;
45903 }
45904
45905
45906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
45907   void * jresult ;
45908   Dali::CameraActor result;
45909
45910   {
45911     try {
45912       result = Dali::CameraActor::New();
45913     } catch (std::out_of_range& e) {
45914       {
45915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45916       };
45917     } catch (std::exception& e) {
45918       {
45919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45920       };
45921     } catch (Dali::DaliException e) {
45922       {
45923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45924       };
45925     } catch (...) {
45926       {
45927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45928       };
45929     }
45930   }
45931
45932   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45933   return jresult;
45934 }
45935
45936
45937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
45938   void * jresult ;
45939   Dali::Size *arg1 = 0 ;
45940   Dali::CameraActor result;
45941
45942   arg1 = (Dali::Size *)jarg1;
45943   if (!arg1) {
45944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45945     return 0;
45946   }
45947   {
45948     try {
45949       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
45950     } catch (std::out_of_range& e) {
45951       {
45952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45953       };
45954     } catch (std::exception& e) {
45955       {
45956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45957       };
45958     } catch (Dali::DaliException e) {
45959       {
45960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45961       };
45962     } catch (...) {
45963       {
45964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45965       };
45966     }
45967   }
45968
45969   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45970   return jresult;
45971 }
45972
45973
45974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
45975   void * jresult ;
45976   Dali::BaseHandle arg1 ;
45977   Dali::BaseHandle *argp1 ;
45978   Dali::CameraActor result;
45979
45980   argp1 = (Dali::BaseHandle *)jarg1;
45981   if (!argp1) {
45982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45983     return 0;
45984   }
45985   arg1 = *argp1;
45986   {
45987     try {
45988       result = Dali::CameraActor::DownCast(arg1);
45989     } catch (std::out_of_range& e) {
45990       {
45991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45992       };
45993     } catch (std::exception& e) {
45994       {
45995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45996       };
45997     } catch (Dali::DaliException e) {
45998       {
45999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46000       };
46001     } catch (...) {
46002       {
46003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46004       };
46005     }
46006   }
46007
46008   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
46009   return jresult;
46010 }
46011
46012
46013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
46014   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46015
46016   arg1 = (Dali::CameraActor *)jarg1;
46017   {
46018     try {
46019       delete arg1;
46020     } catch (std::out_of_range& e) {
46021       {
46022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46023       };
46024     } catch (std::exception& e) {
46025       {
46026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46027       };
46028     } catch (Dali::DaliException e) {
46029       {
46030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46031       };
46032     } catch (...) {
46033       {
46034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46035       };
46036     }
46037   }
46038
46039 }
46040
46041
46042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
46043   void * jresult ;
46044   Dali::CameraActor *arg1 = 0 ;
46045   Dali::CameraActor *result = 0 ;
46046
46047   arg1 = (Dali::CameraActor *)jarg1;
46048   if (!arg1) {
46049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
46050     return 0;
46051   }
46052   {
46053     try {
46054       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
46055     } catch (std::out_of_range& e) {
46056       {
46057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46058       };
46059     } catch (std::exception& e) {
46060       {
46061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46062       };
46063     } catch (Dali::DaliException e) {
46064       {
46065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46066       };
46067     } catch (...) {
46068       {
46069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46070       };
46071     }
46072   }
46073
46074   jresult = (void *)result;
46075   return jresult;
46076 }
46077
46078
46079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
46080   void * jresult ;
46081   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46082   Dali::CameraActor *arg2 = 0 ;
46083   Dali::CameraActor *result = 0 ;
46084
46085   arg1 = (Dali::CameraActor *)jarg1;
46086   arg2 = (Dali::CameraActor *)jarg2;
46087   if (!arg2) {
46088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
46089     return 0;
46090   }
46091   {
46092     try {
46093       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
46094     } catch (std::out_of_range& e) {
46095       {
46096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46097       };
46098     } catch (std::exception& e) {
46099       {
46100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46101       };
46102     } catch (Dali::DaliException e) {
46103       {
46104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46105       };
46106     } catch (...) {
46107       {
46108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46109       };
46110     }
46111   }
46112
46113   jresult = (void *)result;
46114   return jresult;
46115 }
46116
46117
46118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
46119   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46120   Dali::Camera::Type arg2 ;
46121
46122   arg1 = (Dali::CameraActor *)jarg1;
46123   arg2 = (Dali::Camera::Type)jarg2;
46124   {
46125     try {
46126       (arg1)->SetType(arg2);
46127     } catch (std::out_of_range& e) {
46128       {
46129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46130       };
46131     } catch (std::exception& e) {
46132       {
46133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46134       };
46135     } catch (Dali::DaliException e) {
46136       {
46137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46138       };
46139     } catch (...) {
46140       {
46141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46142       };
46143     }
46144   }
46145
46146 }
46147
46148
46149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
46150   int jresult ;
46151   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46152   Dali::Camera::Type result;
46153
46154   arg1 = (Dali::CameraActor *)jarg1;
46155   {
46156     try {
46157       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
46158     } catch (std::out_of_range& e) {
46159       {
46160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46161       };
46162     } catch (std::exception& e) {
46163       {
46164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46165       };
46166     } catch (Dali::DaliException e) {
46167       {
46168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46169       };
46170     } catch (...) {
46171       {
46172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46173       };
46174     }
46175   }
46176
46177   jresult = (int)result;
46178   return jresult;
46179 }
46180
46181
46182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
46183   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46184   Dali::Camera::ProjectionMode arg2 ;
46185
46186   arg1 = (Dali::CameraActor *)jarg1;
46187   arg2 = (Dali::Camera::ProjectionMode)jarg2;
46188   {
46189     try {
46190       (arg1)->SetProjectionMode(arg2);
46191     } catch (std::out_of_range& e) {
46192       {
46193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46194       };
46195     } catch (std::exception& e) {
46196       {
46197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46198       };
46199     } catch (Dali::DaliException e) {
46200       {
46201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46202       };
46203     } catch (...) {
46204       {
46205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46206       };
46207     }
46208   }
46209
46210 }
46211
46212
46213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
46214   int jresult ;
46215   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46216   Dali::Camera::ProjectionMode result;
46217
46218   arg1 = (Dali::CameraActor *)jarg1;
46219   {
46220     try {
46221       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
46222     } catch (std::out_of_range& e) {
46223       {
46224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46225       };
46226     } catch (std::exception& e) {
46227       {
46228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46229       };
46230     } catch (Dali::DaliException e) {
46231       {
46232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46233       };
46234     } catch (...) {
46235       {
46236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46237       };
46238     }
46239   }
46240
46241   jresult = (int)result;
46242   return jresult;
46243 }
46244
46245
46246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
46247   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46248   float arg2 ;
46249
46250   arg1 = (Dali::CameraActor *)jarg1;
46251   arg2 = (float)jarg2;
46252   {
46253     try {
46254       (arg1)->SetFieldOfView(arg2);
46255     } catch (std::out_of_range& e) {
46256       {
46257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46258       };
46259     } catch (std::exception& e) {
46260       {
46261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46262       };
46263     } catch (Dali::DaliException e) {
46264       {
46265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46266       };
46267     } catch (...) {
46268       {
46269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46270       };
46271     }
46272   }
46273
46274 }
46275
46276
46277 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
46278   float jresult ;
46279   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46280   float result;
46281
46282   arg1 = (Dali::CameraActor *)jarg1;
46283   {
46284     try {
46285       result = (float)(arg1)->GetFieldOfView();
46286     } catch (std::out_of_range& e) {
46287       {
46288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46289       };
46290     } catch (std::exception& e) {
46291       {
46292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46293       };
46294     } catch (Dali::DaliException e) {
46295       {
46296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46297       };
46298     } catch (...) {
46299       {
46300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46301       };
46302     }
46303   }
46304
46305   jresult = result;
46306   return jresult;
46307 }
46308
46309
46310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
46311   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46312   float arg2 ;
46313
46314   arg1 = (Dali::CameraActor *)jarg1;
46315   arg2 = (float)jarg2;
46316   {
46317     try {
46318       (arg1)->SetAspectRatio(arg2);
46319     } catch (std::out_of_range& e) {
46320       {
46321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46322       };
46323     } catch (std::exception& e) {
46324       {
46325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46326       };
46327     } catch (Dali::DaliException e) {
46328       {
46329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46330       };
46331     } catch (...) {
46332       {
46333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46334       };
46335     }
46336   }
46337
46338 }
46339
46340
46341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
46342   float jresult ;
46343   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46344   float result;
46345
46346   arg1 = (Dali::CameraActor *)jarg1;
46347   {
46348     try {
46349       result = (float)(arg1)->GetAspectRatio();
46350     } catch (std::out_of_range& e) {
46351       {
46352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46353       };
46354     } catch (std::exception& e) {
46355       {
46356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46357       };
46358     } catch (Dali::DaliException e) {
46359       {
46360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46361       };
46362     } catch (...) {
46363       {
46364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46365       };
46366     }
46367   }
46368
46369   jresult = result;
46370   return jresult;
46371 }
46372
46373
46374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
46375   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46376   float arg2 ;
46377
46378   arg1 = (Dali::CameraActor *)jarg1;
46379   arg2 = (float)jarg2;
46380   {
46381     try {
46382       (arg1)->SetNearClippingPlane(arg2);
46383     } catch (std::out_of_range& e) {
46384       {
46385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46386       };
46387     } catch (std::exception& e) {
46388       {
46389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46390       };
46391     } catch (Dali::DaliException e) {
46392       {
46393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46394       };
46395     } catch (...) {
46396       {
46397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46398       };
46399     }
46400   }
46401
46402 }
46403
46404
46405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
46406   float jresult ;
46407   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46408   float result;
46409
46410   arg1 = (Dali::CameraActor *)jarg1;
46411   {
46412     try {
46413       result = (float)(arg1)->GetNearClippingPlane();
46414     } catch (std::out_of_range& e) {
46415       {
46416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46417       };
46418     } catch (std::exception& e) {
46419       {
46420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46421       };
46422     } catch (Dali::DaliException e) {
46423       {
46424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46425       };
46426     } catch (...) {
46427       {
46428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46429       };
46430     }
46431   }
46432
46433   jresult = result;
46434   return jresult;
46435 }
46436
46437
46438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
46439   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46440   float arg2 ;
46441
46442   arg1 = (Dali::CameraActor *)jarg1;
46443   arg2 = (float)jarg2;
46444   {
46445     try {
46446       (arg1)->SetFarClippingPlane(arg2);
46447     } catch (std::out_of_range& e) {
46448       {
46449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46450       };
46451     } catch (std::exception& e) {
46452       {
46453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46454       };
46455     } catch (Dali::DaliException e) {
46456       {
46457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46458       };
46459     } catch (...) {
46460       {
46461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46462       };
46463     }
46464   }
46465
46466 }
46467
46468
46469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
46470   float jresult ;
46471   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46472   float result;
46473
46474   arg1 = (Dali::CameraActor *)jarg1;
46475   {
46476     try {
46477       result = (float)(arg1)->GetFarClippingPlane();
46478     } catch (std::out_of_range& e) {
46479       {
46480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46481       };
46482     } catch (std::exception& e) {
46483       {
46484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46485       };
46486     } catch (Dali::DaliException e) {
46487       {
46488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46489       };
46490     } catch (...) {
46491       {
46492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46493       };
46494     }
46495   }
46496
46497   jresult = result;
46498   return jresult;
46499 }
46500
46501
46502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
46503   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46504   Dali::Vector3 *arg2 = 0 ;
46505
46506   arg1 = (Dali::CameraActor *)jarg1;
46507   arg2 = (Dali::Vector3 *)jarg2;
46508   if (!arg2) {
46509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
46510     return ;
46511   }
46512   {
46513     try {
46514       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
46515     } catch (std::out_of_range& e) {
46516       {
46517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46518       };
46519     } catch (std::exception& e) {
46520       {
46521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46522       };
46523     } catch (Dali::DaliException e) {
46524       {
46525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46526       };
46527     } catch (...) {
46528       {
46529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46530       };
46531     }
46532   }
46533
46534 }
46535
46536
46537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
46538   void * jresult ;
46539   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46540   Dali::Vector3 result;
46541
46542   arg1 = (Dali::CameraActor *)jarg1;
46543   {
46544     try {
46545       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
46546     } catch (std::out_of_range& e) {
46547       {
46548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46549       };
46550     } catch (std::exception& e) {
46551       {
46552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46553       };
46554     } catch (Dali::DaliException e) {
46555       {
46556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46557       };
46558     } catch (...) {
46559       {
46560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46561       };
46562     }
46563   }
46564
46565   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
46566   return jresult;
46567 }
46568
46569
46570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
46571   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46572   bool arg2 ;
46573
46574   arg1 = (Dali::CameraActor *)jarg1;
46575   arg2 = jarg2 ? true : false;
46576   {
46577     try {
46578       (arg1)->SetInvertYAxis(arg2);
46579     } catch (std::out_of_range& e) {
46580       {
46581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46582       };
46583     } catch (std::exception& e) {
46584       {
46585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46586       };
46587     } catch (Dali::DaliException e) {
46588       {
46589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46590       };
46591     } catch (...) {
46592       {
46593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46594       };
46595     }
46596   }
46597
46598 }
46599
46600
46601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
46602   unsigned int jresult ;
46603   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46604   bool result;
46605
46606   arg1 = (Dali::CameraActor *)jarg1;
46607   {
46608     try {
46609       result = (bool)(arg1)->GetInvertYAxis();
46610     } catch (std::out_of_range& e) {
46611       {
46612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46613       };
46614     } catch (std::exception& e) {
46615       {
46616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46617       };
46618     } catch (Dali::DaliException e) {
46619       {
46620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46621       };
46622     } catch (...) {
46623       {
46624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46625       };
46626     }
46627   }
46628
46629   jresult = result;
46630   return jresult;
46631 }
46632
46633
46634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
46635   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46636   Dali::Size *arg2 = 0 ;
46637
46638   arg1 = (Dali::CameraActor *)jarg1;
46639   arg2 = (Dali::Size *)jarg2;
46640   if (!arg2) {
46641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
46642     return ;
46643   }
46644   {
46645     try {
46646       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
46647     } catch (std::out_of_range& e) {
46648       {
46649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46650       };
46651     } catch (std::exception& e) {
46652       {
46653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46654       };
46655     } catch (Dali::DaliException e) {
46656       {
46657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46658       };
46659     } catch (...) {
46660       {
46661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46662       };
46663     }
46664   }
46665
46666 }
46667
46668
46669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
46670   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46671   Dali::Size *arg2 = 0 ;
46672
46673   arg1 = (Dali::CameraActor *)jarg1;
46674   arg2 = (Dali::Size *)jarg2;
46675   if (!arg2) {
46676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
46677     return ;
46678   }
46679   {
46680     try {
46681       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
46682     } catch (std::out_of_range& e) {
46683       {
46684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46685       };
46686     } catch (std::exception& e) {
46687       {
46688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46689       };
46690     } catch (Dali::DaliException e) {
46691       {
46692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46693       };
46694     } catch (...) {
46695       {
46696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46697       };
46698     }
46699   }
46700
46701 }
46702
46703
46704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
46705   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46706   float arg2 ;
46707   float arg3 ;
46708   float arg4 ;
46709   float arg5 ;
46710   float arg6 ;
46711   float arg7 ;
46712
46713   arg1 = (Dali::CameraActor *)jarg1;
46714   arg2 = (float)jarg2;
46715   arg3 = (float)jarg3;
46716   arg4 = (float)jarg4;
46717   arg5 = (float)jarg5;
46718   arg6 = (float)jarg6;
46719   arg7 = (float)jarg7;
46720   {
46721     try {
46722       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
46723     } catch (std::out_of_range& e) {
46724       {
46725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46726       };
46727     } catch (std::exception& e) {
46728       {
46729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46730       };
46731     } catch (Dali::DaliException e) {
46732       {
46733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46734       };
46735     } catch (...) {
46736       {
46737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46738       };
46739     }
46740   }
46741
46742 }
46743
46744
46745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
46746   void * jresult ;
46747   std::pair< std::string,Dali::Property::Value > *result = 0 ;
46748
46749   {
46750     try {
46751       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
46752     } catch (std::out_of_range& e) {
46753       {
46754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46755       };
46756     } catch (std::exception& e) {
46757       {
46758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46759       };
46760     } catch (Dali::DaliException e) {
46761       {
46762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46763       };
46764     } catch (...) {
46765       {
46766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46767       };
46768     }
46769   }
46770
46771   jresult = (void *)result;
46772   return jresult;
46773 }
46774
46775
46776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
46777   void * jresult ;
46778   std::string arg1 ;
46779   Dali::Property::Value arg2 ;
46780   Dali::Property::Value *argp2 ;
46781   std::pair< std::string,Dali::Property::Value > *result = 0 ;
46782
46783   if (!jarg1) {
46784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46785     return 0;
46786   }
46787   (&arg1)->assign(jarg1);
46788   argp2 = (Dali::Property::Value *)jarg2;
46789   if (!argp2) {
46790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
46791     return 0;
46792   }
46793   arg2 = *argp2;
46794   {
46795     try {
46796       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
46797     } catch (std::out_of_range& e) {
46798       {
46799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46800       };
46801     } catch (std::exception& e) {
46802       {
46803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46804       };
46805     } catch (Dali::DaliException e) {
46806       {
46807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46808       };
46809     } catch (...) {
46810       {
46811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46812       };
46813     }
46814   }
46815
46816   jresult = (void *)result;
46817   return jresult;
46818 }
46819
46820
46821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
46822   void * jresult ;
46823   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
46824   std::pair< std::string,Dali::Property::Value > *result = 0 ;
46825
46826   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46827   if (!arg1) {
46828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
46829     return 0;
46830   }
46831   {
46832     try {
46833       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);
46834     } catch (std::out_of_range& e) {
46835       {
46836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46837       };
46838     } catch (std::exception& e) {
46839       {
46840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46841       };
46842     } catch (Dali::DaliException e) {
46843       {
46844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46845       };
46846     } catch (...) {
46847       {
46848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46849       };
46850     }
46851   }
46852
46853   jresult = (void *)result;
46854   return jresult;
46855 }
46856
46857
46858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
46859   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46860   std::string *arg2 = 0 ;
46861
46862   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46863   if (!jarg2) {
46864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46865     return ;
46866   }
46867   std::string arg2_str(jarg2);
46868   arg2 = &arg2_str;
46869   if (arg1) (arg1)->first = *arg2;
46870
46871   //argout typemap for const std::string&
46872
46873 }
46874
46875
46876 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
46877   char * jresult ;
46878   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46879   std::string *result = 0 ;
46880
46881   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46882   result = (std::string *) & ((arg1)->first);
46883   jresult = SWIG_csharp_string_callback(result->c_str());
46884   return jresult;
46885 }
46886
46887
46888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
46889   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46890   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
46891
46892   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46893   arg2 = (Dali::Property::Value *)jarg2;
46894   if (arg1) (arg1)->second = *arg2;
46895 }
46896
46897
46898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
46899   void * jresult ;
46900   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46901   Dali::Property::Value *result = 0 ;
46902
46903   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46904   result = (Dali::Property::Value *)& ((arg1)->second);
46905   jresult = (void *)result;
46906   return jresult;
46907 }
46908
46909
46910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
46911   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46912
46913   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46914   {
46915     try {
46916       delete arg1;
46917     } catch (std::out_of_range& e) {
46918       {
46919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46920       };
46921     } catch (std::exception& e) {
46922       {
46923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46924       };
46925     } catch (Dali::DaliException e) {
46926       {
46927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46928       };
46929     } catch (...) {
46930       {
46931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46932       };
46933     }
46934   }
46935
46936 }
46937
46938
46939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
46940   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46941
46942   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46943   {
46944     try {
46945       (arg1)->clear();
46946     } catch (std::out_of_range& e) {
46947       {
46948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46949       };
46950     } catch (std::exception& e) {
46951       {
46952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46953       };
46954     } catch (Dali::DaliException e) {
46955       {
46956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46957       };
46958     } catch (...) {
46959       {
46960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46961       };
46962     }
46963   }
46964
46965 }
46966
46967
46968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
46969   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46970   Dali::TouchPoint *arg2 = 0 ;
46971
46972   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46973   arg2 = (Dali::TouchPoint *)jarg2;
46974   if (!arg2) {
46975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46976     return ;
46977   }
46978   {
46979     try {
46980       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
46981     } catch (std::out_of_range& e) {
46982       {
46983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46984       };
46985     } catch (std::exception& e) {
46986       {
46987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46988       };
46989     } catch (Dali::DaliException e) {
46990       {
46991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46992       };
46993     } catch (...) {
46994       {
46995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46996       };
46997     }
46998   }
46999
47000 }
47001
47002
47003 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
47004   unsigned long jresult ;
47005   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47006   std::vector< Dali::TouchPoint >::size_type result;
47007
47008   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47009   {
47010     try {
47011       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
47012     } catch (std::out_of_range& e) {
47013       {
47014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47015       };
47016     } catch (std::exception& e) {
47017       {
47018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47019       };
47020     } catch (Dali::DaliException e) {
47021       {
47022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47023       };
47024     } catch (...) {
47025       {
47026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47027       };
47028     }
47029   }
47030
47031   jresult = (unsigned long)result;
47032   return jresult;
47033 }
47034
47035
47036 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
47037   unsigned long jresult ;
47038   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47039   std::vector< Dali::TouchPoint >::size_type result;
47040
47041   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47042   {
47043     try {
47044       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
47045     } catch (std::out_of_range& e) {
47046       {
47047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47048       };
47049     } catch (std::exception& e) {
47050       {
47051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47052       };
47053     } catch (Dali::DaliException e) {
47054       {
47055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47056       };
47057     } catch (...) {
47058       {
47059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47060       };
47061     }
47062   }
47063
47064   jresult = (unsigned long)result;
47065   return jresult;
47066 }
47067
47068
47069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
47070   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47071   std::vector< Dali::TouchPoint >::size_type arg2 ;
47072
47073   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47074   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
47075   {
47076     try {
47077       (arg1)->reserve(arg2);
47078     } catch (std::out_of_range& e) {
47079       {
47080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47081       };
47082     } catch (std::exception& e) {
47083       {
47084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47085       };
47086     } catch (Dali::DaliException e) {
47087       {
47088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47089       };
47090     } catch (...) {
47091       {
47092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47093       };
47094     }
47095   }
47096
47097 }
47098
47099
47100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
47101   void * jresult ;
47102   std::vector< Dali::TouchPoint > *result = 0 ;
47103
47104   {
47105     try {
47106       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
47107     } catch (std::out_of_range& e) {
47108       {
47109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47110       };
47111     } catch (std::exception& e) {
47112       {
47113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47114       };
47115     } catch (Dali::DaliException e) {
47116       {
47117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47118       };
47119     } catch (...) {
47120       {
47121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47122       };
47123     }
47124   }
47125
47126   jresult = (void *)result;
47127   return jresult;
47128 }
47129
47130
47131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
47132   void * jresult ;
47133   std::vector< Dali::TouchPoint > *arg1 = 0 ;
47134   std::vector< Dali::TouchPoint > *result = 0 ;
47135
47136   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47137   if (!arg1) {
47138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
47139     return 0;
47140   }
47141   {
47142     try {
47143       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
47144     } catch (std::out_of_range& e) {
47145       {
47146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47147       };
47148     } catch (std::exception& e) {
47149       {
47150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47151       };
47152     } catch (Dali::DaliException e) {
47153       {
47154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47155       };
47156     } catch (...) {
47157       {
47158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47159       };
47160     }
47161   }
47162
47163   jresult = (void *)result;
47164   return jresult;
47165 }
47166
47167
47168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
47169   void * jresult ;
47170   int arg1 ;
47171   std::vector< Dali::TouchPoint > *result = 0 ;
47172
47173   arg1 = (int)jarg1;
47174   {
47175     try {
47176       try {
47177         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
47178       }
47179       catch(std::out_of_range &_e) {
47180         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47181         return 0;
47182       }
47183
47184     } catch (std::out_of_range& e) {
47185       {
47186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47187       };
47188     } catch (std::exception& e) {
47189       {
47190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47191       };
47192     } catch (Dali::DaliException e) {
47193       {
47194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47195       };
47196     } catch (...) {
47197       {
47198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47199       };
47200     }
47201   }
47202
47203   jresult = (void *)result;
47204   return jresult;
47205 }
47206
47207
47208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
47209   void * jresult ;
47210   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47211   int arg2 ;
47212   SwigValueWrapper< Dali::TouchPoint > result;
47213
47214   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47215   arg2 = (int)jarg2;
47216   {
47217     try {
47218       try {
47219         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
47220       }
47221       catch(std::out_of_range &_e) {
47222         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47223         return 0;
47224       }
47225
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::TouchPoint((const Dali::TouchPoint &)result);
47246   return jresult;
47247 }
47248
47249
47250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
47251   void * jresult ;
47252   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47253   int arg2 ;
47254   Dali::TouchPoint *result = 0 ;
47255
47256   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47257   arg2 = (int)jarg2;
47258   {
47259     try {
47260       try {
47261         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
47262       }
47263       catch(std::out_of_range &_e) {
47264         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47265         return 0;
47266       }
47267
47268     } catch (std::out_of_range& e) {
47269       {
47270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47271       };
47272     } catch (std::exception& e) {
47273       {
47274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47275       };
47276     } catch (Dali::DaliException e) {
47277       {
47278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47279       };
47280     } catch (...) {
47281       {
47282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47283       };
47284     }
47285   }
47286
47287   jresult = (void *)result;
47288   return jresult;
47289 }
47290
47291
47292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
47293   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47294   int arg2 ;
47295   Dali::TouchPoint *arg3 = 0 ;
47296
47297   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47298   arg2 = (int)jarg2;
47299   arg3 = (Dali::TouchPoint *)jarg3;
47300   if (!arg3) {
47301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
47302     return ;
47303   }
47304   {
47305     try {
47306       try {
47307         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
47308       }
47309       catch(std::out_of_range &_e) {
47310         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47311         return ;
47312       }
47313
47314     } catch (std::out_of_range& e) {
47315       {
47316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47317       };
47318     } catch (std::exception& e) {
47319       {
47320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47321       };
47322     } catch (Dali::DaliException e) {
47323       {
47324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47325       };
47326     } catch (...) {
47327       {
47328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47329       };
47330     }
47331   }
47332
47333 }
47334
47335
47336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
47337   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47338   std::vector< Dali::TouchPoint > *arg2 = 0 ;
47339
47340   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47341   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
47342   if (!arg2) {
47343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
47344     return ;
47345   }
47346   {
47347     try {
47348       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
47349     } catch (std::out_of_range& e) {
47350       {
47351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47352       };
47353     } catch (std::exception& e) {
47354       {
47355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47356       };
47357     } catch (Dali::DaliException e) {
47358       {
47359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47360       };
47361     } catch (...) {
47362       {
47363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47364       };
47365     }
47366   }
47367
47368 }
47369
47370
47371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
47372   void * jresult ;
47373   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47374   int arg2 ;
47375   int arg3 ;
47376   std::vector< Dali::TouchPoint > *result = 0 ;
47377
47378   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47379   arg2 = (int)jarg2;
47380   arg3 = (int)jarg3;
47381   {
47382     try {
47383       try {
47384         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
47385       }
47386       catch(std::out_of_range &_e) {
47387         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47388         return 0;
47389       }
47390       catch(std::invalid_argument &_e) {
47391         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
47392         return 0;
47393       }
47394
47395     } catch (std::out_of_range& e) {
47396       {
47397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47398       };
47399     } catch (std::exception& e) {
47400       {
47401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47402       };
47403     } catch (Dali::DaliException e) {
47404       {
47405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47406       };
47407     } catch (...) {
47408       {
47409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47410       };
47411     }
47412   }
47413
47414   jresult = (void *)result;
47415   return jresult;
47416 }
47417
47418
47419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
47420   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47421   int arg2 ;
47422   Dali::TouchPoint *arg3 = 0 ;
47423
47424   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47425   arg2 = (int)jarg2;
47426   arg3 = (Dali::TouchPoint *)jarg3;
47427   if (!arg3) {
47428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
47429     return ;
47430   }
47431   {
47432     try {
47433       try {
47434         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
47435       }
47436       catch(std::out_of_range &_e) {
47437         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47438         return ;
47439       }
47440
47441     } catch (std::out_of_range& e) {
47442       {
47443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47444       };
47445     } catch (std::exception& e) {
47446       {
47447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47448       };
47449     } catch (Dali::DaliException e) {
47450       {
47451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47452       };
47453     } catch (...) {
47454       {
47455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47456       };
47457     }
47458   }
47459
47460 }
47461
47462
47463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
47464   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47465   int arg2 ;
47466   std::vector< Dali::TouchPoint > *arg3 = 0 ;
47467
47468   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47469   arg2 = (int)jarg2;
47470   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
47471   if (!arg3) {
47472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
47473     return ;
47474   }
47475   {
47476     try {
47477       try {
47478         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
47479       }
47480       catch(std::out_of_range &_e) {
47481         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47482         return ;
47483       }
47484
47485     } catch (std::out_of_range& e) {
47486       {
47487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47488       };
47489     } catch (std::exception& e) {
47490       {
47491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47492       };
47493     } catch (Dali::DaliException e) {
47494       {
47495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47496       };
47497     } catch (...) {
47498       {
47499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47500       };
47501     }
47502   }
47503
47504 }
47505
47506
47507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
47508   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47509   int arg2 ;
47510
47511   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47512   arg2 = (int)jarg2;
47513   {
47514     try {
47515       try {
47516         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
47517       }
47518       catch(std::out_of_range &_e) {
47519         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47520         return ;
47521       }
47522
47523     } catch (std::out_of_range& e) {
47524       {
47525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47526       };
47527     } catch (std::exception& e) {
47528       {
47529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47530       };
47531     } catch (Dali::DaliException e) {
47532       {
47533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47534       };
47535     } catch (...) {
47536       {
47537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47538       };
47539     }
47540   }
47541
47542 }
47543
47544
47545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
47546   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47547   int arg2 ;
47548   int arg3 ;
47549
47550   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47551   arg2 = (int)jarg2;
47552   arg3 = (int)jarg3;
47553   {
47554     try {
47555       try {
47556         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
47557       }
47558       catch(std::out_of_range &_e) {
47559         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47560         return ;
47561       }
47562       catch(std::invalid_argument &_e) {
47563         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
47564         return ;
47565       }
47566
47567     } catch (std::out_of_range& e) {
47568       {
47569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47570       };
47571     } catch (std::exception& e) {
47572       {
47573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47574       };
47575     } catch (Dali::DaliException e) {
47576       {
47577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47578       };
47579     } catch (...) {
47580       {
47581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47582       };
47583     }
47584   }
47585
47586 }
47587
47588
47589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
47590   void * jresult ;
47591   Dali::TouchPoint *arg1 = 0 ;
47592   int arg2 ;
47593   std::vector< Dali::TouchPoint > *result = 0 ;
47594
47595   arg1 = (Dali::TouchPoint *)jarg1;
47596   if (!arg1) {
47597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
47598     return 0;
47599   }
47600   arg2 = (int)jarg2;
47601   {
47602     try {
47603       try {
47604         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
47605       }
47606       catch(std::out_of_range &_e) {
47607         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47608         return 0;
47609       }
47610
47611     } catch (std::out_of_range& e) {
47612       {
47613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47614       };
47615     } catch (std::exception& e) {
47616       {
47617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47618       };
47619     } catch (Dali::DaliException e) {
47620       {
47621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47622       };
47623     } catch (...) {
47624       {
47625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47626       };
47627     }
47628   }
47629
47630   jresult = (void *)result;
47631   return jresult;
47632 }
47633
47634
47635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
47636   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47637
47638   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47639   {
47640     try {
47641       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
47642     } catch (std::out_of_range& e) {
47643       {
47644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47645       };
47646     } catch (std::exception& e) {
47647       {
47648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47649       };
47650     } catch (Dali::DaliException e) {
47651       {
47652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47653       };
47654     } catch (...) {
47655       {
47656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47657       };
47658     }
47659   }
47660
47661 }
47662
47663
47664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
47665   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47666   int arg2 ;
47667   int arg3 ;
47668
47669   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47670   arg2 = (int)jarg2;
47671   arg3 = (int)jarg3;
47672   {
47673     try {
47674       try {
47675         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
47676       }
47677       catch(std::out_of_range &_e) {
47678         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47679         return ;
47680       }
47681       catch(std::invalid_argument &_e) {
47682         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
47683         return ;
47684       }
47685
47686     } catch (std::out_of_range& e) {
47687       {
47688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47689       };
47690     } catch (std::exception& e) {
47691       {
47692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47693       };
47694     } catch (Dali::DaliException e) {
47695       {
47696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47697       };
47698     } catch (...) {
47699       {
47700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47701       };
47702     }
47703   }
47704
47705 }
47706
47707
47708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
47709   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47710   int arg2 ;
47711   std::vector< Dali::TouchPoint > *arg3 = 0 ;
47712
47713   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47714   arg2 = (int)jarg2;
47715   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
47716   if (!arg3) {
47717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
47718     return ;
47719   }
47720   {
47721     try {
47722       try {
47723         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
47724       }
47725       catch(std::out_of_range &_e) {
47726         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47727         return ;
47728       }
47729
47730     } catch (std::out_of_range& e) {
47731       {
47732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47733       };
47734     } catch (std::exception& e) {
47735       {
47736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47737       };
47738     } catch (Dali::DaliException e) {
47739       {
47740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47741       };
47742     } catch (...) {
47743       {
47744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47745       };
47746     }
47747   }
47748
47749 }
47750
47751
47752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
47753   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47754
47755   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47756   {
47757     try {
47758       delete arg1;
47759     } catch (std::out_of_range& e) {
47760       {
47761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47762       };
47763     } catch (std::exception& e) {
47764       {
47765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47766       };
47767     } catch (Dali::DaliException e) {
47768       {
47769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47770       };
47771     } catch (...) {
47772       {
47773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47774       };
47775     }
47776   }
47777
47778 }
47779
47780
47781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
47782   void * jresult ;
47783   Dali::Rect< int > *result = 0 ;
47784
47785   {
47786     try {
47787       result = (Dali::Rect< int > *)new Dali::Rect< int >();
47788     } catch (std::out_of_range& e) {
47789       {
47790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47791       };
47792     } catch (std::exception& e) {
47793       {
47794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47795       };
47796     } catch (Dali::DaliException e) {
47797       {
47798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47799       };
47800     } catch (...) {
47801       {
47802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47803       };
47804     }
47805   }
47806
47807   jresult = (void *)result;
47808   return jresult;
47809 }
47810
47811
47812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
47813   void * jresult ;
47814   int arg1 ;
47815   int arg2 ;
47816   int arg3 ;
47817   int arg4 ;
47818   Dali::Rect< int > *result = 0 ;
47819
47820   arg1 = (int)jarg1;
47821   arg2 = (int)jarg2;
47822   arg3 = (int)jarg3;
47823   arg4 = (int)jarg4;
47824   {
47825     try {
47826       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
47827     } catch (std::out_of_range& e) {
47828       {
47829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47830       };
47831     } catch (std::exception& e) {
47832       {
47833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47834       };
47835     } catch (Dali::DaliException e) {
47836       {
47837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47838       };
47839     } catch (...) {
47840       {
47841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47842       };
47843     }
47844   }
47845
47846   jresult = (void *)result;
47847   return jresult;
47848 }
47849
47850
47851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
47852   void * jresult ;
47853   Dali::Rect< int > *arg1 = 0 ;
47854   Dali::Rect< int > *result = 0 ;
47855
47856   arg1 = (Dali::Rect< int > *)jarg1;
47857   if (!arg1) {
47858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47859     return 0;
47860   }
47861   {
47862     try {
47863       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
47864     } catch (std::out_of_range& e) {
47865       {
47866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47867       };
47868     } catch (std::exception& e) {
47869       {
47870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47871       };
47872     } catch (Dali::DaliException e) {
47873       {
47874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47875       };
47876     } catch (...) {
47877       {
47878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47879       };
47880     }
47881   }
47882
47883   jresult = (void *)result;
47884   return jresult;
47885 }
47886
47887
47888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
47889   void * jresult ;
47890   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47891   Dali::Rect< int > *arg2 = 0 ;
47892   Dali::Rect< int > *result = 0 ;
47893
47894   arg1 = (Dali::Rect< int > *)jarg1;
47895   arg2 = (Dali::Rect< int > *)jarg2;
47896   if (!arg2) {
47897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47898     return 0;
47899   }
47900   {
47901     try {
47902       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
47903     } catch (std::out_of_range& e) {
47904       {
47905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47906       };
47907     } catch (std::exception& e) {
47908       {
47909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47910       };
47911     } catch (Dali::DaliException e) {
47912       {
47913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47914       };
47915     } catch (...) {
47916       {
47917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47918       };
47919     }
47920   }
47921
47922   jresult = (void *)result;
47923   return jresult;
47924 }
47925
47926
47927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
47928   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47929   int arg2 ;
47930   int arg3 ;
47931   int arg4 ;
47932   int arg5 ;
47933
47934   arg1 = (Dali::Rect< int > *)jarg1;
47935   arg2 = (int)jarg2;
47936   arg3 = (int)jarg3;
47937   arg4 = (int)jarg4;
47938   arg5 = (int)jarg5;
47939   {
47940     try {
47941       (arg1)->Set(arg2,arg3,arg4,arg5);
47942     } catch (std::out_of_range& e) {
47943       {
47944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47945       };
47946     } catch (std::exception& e) {
47947       {
47948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47949       };
47950     } catch (Dali::DaliException e) {
47951       {
47952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47953       };
47954     } catch (...) {
47955       {
47956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47957       };
47958     }
47959   }
47960
47961 }
47962
47963
47964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
47965   unsigned int jresult ;
47966   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47967   bool result;
47968
47969   arg1 = (Dali::Rect< int > *)jarg1;
47970   {
47971     try {
47972       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
47973     } catch (std::out_of_range& e) {
47974       {
47975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47976       };
47977     } catch (std::exception& e) {
47978       {
47979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47980       };
47981     } catch (Dali::DaliException e) {
47982       {
47983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47984       };
47985     } catch (...) {
47986       {
47987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47988       };
47989     }
47990   }
47991
47992   jresult = result;
47993   return jresult;
47994 }
47995
47996
47997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
47998   int jresult ;
47999   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48000   int result;
48001
48002   arg1 = (Dali::Rect< int > *)jarg1;
48003   {
48004     try {
48005       result = (int)((Dali::Rect< int > const *)arg1)->Left();
48006     } catch (std::out_of_range& e) {
48007       {
48008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48009       };
48010     } catch (std::exception& e) {
48011       {
48012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48013       };
48014     } catch (Dali::DaliException e) {
48015       {
48016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48017       };
48018     } catch (...) {
48019       {
48020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48021       };
48022     }
48023   }
48024
48025   jresult = result;
48026   return jresult;
48027 }
48028
48029
48030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
48031   int jresult ;
48032   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48033   int result;
48034
48035   arg1 = (Dali::Rect< int > *)jarg1;
48036   {
48037     try {
48038       result = (int)((Dali::Rect< int > const *)arg1)->Right();
48039     } catch (std::out_of_range& e) {
48040       {
48041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48042       };
48043     } catch (std::exception& e) {
48044       {
48045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48046       };
48047     } catch (Dali::DaliException e) {
48048       {
48049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48050       };
48051     } catch (...) {
48052       {
48053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48054       };
48055     }
48056   }
48057
48058   jresult = result;
48059   return jresult;
48060 }
48061
48062
48063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
48064   int jresult ;
48065   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48066   int result;
48067
48068   arg1 = (Dali::Rect< int > *)jarg1;
48069   {
48070     try {
48071       result = (int)((Dali::Rect< int > const *)arg1)->Top();
48072     } catch (std::out_of_range& e) {
48073       {
48074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48075       };
48076     } catch (std::exception& e) {
48077       {
48078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48079       };
48080     } catch (Dali::DaliException e) {
48081       {
48082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48083       };
48084     } catch (...) {
48085       {
48086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48087       };
48088     }
48089   }
48090
48091   jresult = result;
48092   return jresult;
48093 }
48094
48095
48096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
48097   int jresult ;
48098   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48099   int result;
48100
48101   arg1 = (Dali::Rect< int > *)jarg1;
48102   {
48103     try {
48104       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
48105     } catch (std::out_of_range& e) {
48106       {
48107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48108       };
48109     } catch (std::exception& e) {
48110       {
48111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48112       };
48113     } catch (Dali::DaliException e) {
48114       {
48115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48116       };
48117     } catch (...) {
48118       {
48119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48120       };
48121     }
48122   }
48123
48124   jresult = result;
48125   return jresult;
48126 }
48127
48128
48129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
48130   int jresult ;
48131   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48132   int result;
48133
48134   arg1 = (Dali::Rect< int > *)jarg1;
48135   {
48136     try {
48137       result = (int)((Dali::Rect< int > const *)arg1)->Area();
48138     } catch (std::out_of_range& e) {
48139       {
48140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48141       };
48142     } catch (std::exception& e) {
48143       {
48144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48145       };
48146     } catch (Dali::DaliException e) {
48147       {
48148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48149       };
48150     } catch (...) {
48151       {
48152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48153       };
48154     }
48155   }
48156
48157   jresult = result;
48158   return jresult;
48159 }
48160
48161
48162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
48163   unsigned int jresult ;
48164   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48165   Dali::Rect< int > *arg2 = 0 ;
48166   bool result;
48167
48168   arg1 = (Dali::Rect< int > *)jarg1;
48169   arg2 = (Dali::Rect< int > *)jarg2;
48170   if (!arg2) {
48171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
48172     return 0;
48173   }
48174   {
48175     try {
48176       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
48177     } catch (std::out_of_range& e) {
48178       {
48179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48180       };
48181     } catch (std::exception& e) {
48182       {
48183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48184       };
48185     } catch (Dali::DaliException e) {
48186       {
48187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48188       };
48189     } catch (...) {
48190       {
48191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48192       };
48193     }
48194   }
48195
48196   jresult = result;
48197   return jresult;
48198 }
48199
48200
48201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
48202   unsigned int jresult ;
48203   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48204   Dali::Rect< int > *arg2 = 0 ;
48205   bool result;
48206
48207   arg1 = (Dali::Rect< int > *)jarg1;
48208   arg2 = (Dali::Rect< int > *)jarg2;
48209   if (!arg2) {
48210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
48211     return 0;
48212   }
48213   {
48214     try {
48215       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
48216     } catch (std::out_of_range& e) {
48217       {
48218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48219       };
48220     } catch (std::exception& e) {
48221       {
48222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48223       };
48224     } catch (Dali::DaliException e) {
48225       {
48226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48227       };
48228     } catch (...) {
48229       {
48230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48231       };
48232     }
48233   }
48234
48235   jresult = result;
48236   return jresult;
48237 }
48238
48239
48240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
48241   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48242   int arg2 ;
48243
48244   arg1 = (Dali::Rect< int > *)jarg1;
48245   arg2 = (int)jarg2;
48246   if (arg1) (arg1)->x = arg2;
48247 }
48248
48249
48250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
48251   int jresult ;
48252   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48253   int result;
48254
48255   arg1 = (Dali::Rect< int > *)jarg1;
48256   result = (int) ((arg1)->x);
48257   jresult = result;
48258   return jresult;
48259 }
48260
48261
48262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
48263   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48264   int arg2 ;
48265
48266   arg1 = (Dali::Rect< int > *)jarg1;
48267   arg2 = (int)jarg2;
48268   if (arg1) (arg1)->left = arg2;
48269 }
48270
48271
48272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
48273   int jresult ;
48274   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48275   int result;
48276
48277   arg1 = (Dali::Rect< int > *)jarg1;
48278   result = (int) ((arg1)->left);
48279   jresult = result;
48280   return jresult;
48281 }
48282
48283
48284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
48285   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48286   int arg2 ;
48287
48288   arg1 = (Dali::Rect< int > *)jarg1;
48289   arg2 = (int)jarg2;
48290   if (arg1) (arg1)->y = arg2;
48291 }
48292
48293
48294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
48295   int jresult ;
48296   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48297   int result;
48298
48299   arg1 = (Dali::Rect< int > *)jarg1;
48300   result = (int) ((arg1)->y);
48301   jresult = result;
48302   return jresult;
48303 }
48304
48305
48306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
48307   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48308   int arg2 ;
48309
48310   arg1 = (Dali::Rect< int > *)jarg1;
48311   arg2 = (int)jarg2;
48312   if (arg1) (arg1)->right = arg2;
48313 }
48314
48315
48316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
48317   int jresult ;
48318   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48319   int result;
48320
48321   arg1 = (Dali::Rect< int > *)jarg1;
48322   result = (int) ((arg1)->right);
48323   jresult = result;
48324   return jresult;
48325 }
48326
48327
48328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
48329   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48330   int arg2 ;
48331
48332   arg1 = (Dali::Rect< int > *)jarg1;
48333   arg2 = (int)jarg2;
48334   if (arg1) (arg1)->width = arg2;
48335 }
48336
48337
48338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
48339   int jresult ;
48340   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48341   int result;
48342
48343   arg1 = (Dali::Rect< int > *)jarg1;
48344   result = (int) ((arg1)->width);
48345   jresult = result;
48346   return jresult;
48347 }
48348
48349
48350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
48351   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48352   int arg2 ;
48353
48354   arg1 = (Dali::Rect< int > *)jarg1;
48355   arg2 = (int)jarg2;
48356   if (arg1) (arg1)->bottom = arg2;
48357 }
48358
48359
48360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
48361   int jresult ;
48362   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48363   int result;
48364
48365   arg1 = (Dali::Rect< int > *)jarg1;
48366   result = (int) ((arg1)->bottom);
48367   jresult = result;
48368   return jresult;
48369 }
48370
48371
48372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
48373   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48374   int arg2 ;
48375
48376   arg1 = (Dali::Rect< int > *)jarg1;
48377   arg2 = (int)jarg2;
48378   if (arg1) (arg1)->height = arg2;
48379 }
48380
48381
48382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
48383   int jresult ;
48384   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48385   int result;
48386
48387   arg1 = (Dali::Rect< int > *)jarg1;
48388   result = (int) ((arg1)->height);
48389   jresult = result;
48390   return jresult;
48391 }
48392
48393
48394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
48395   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48396   int arg2 ;
48397
48398   arg1 = (Dali::Rect< int > *)jarg1;
48399   arg2 = (int)jarg2;
48400   if (arg1) (arg1)->top = arg2;
48401 }
48402
48403
48404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
48405   int jresult ;
48406   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48407   int result;
48408
48409   arg1 = (Dali::Rect< int > *)jarg1;
48410   result = (int) ((arg1)->top);
48411   jresult = result;
48412   return jresult;
48413 }
48414
48415
48416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
48417   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48418
48419   arg1 = (Dali::Rect< int > *)jarg1;
48420   {
48421     try {
48422       delete arg1;
48423     } catch (std::out_of_range& e) {
48424       {
48425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48426       };
48427     } catch (std::exception& e) {
48428       {
48429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48430       };
48431     } catch (Dali::DaliException e) {
48432       {
48433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48434       };
48435     } catch (...) {
48436       {
48437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48438       };
48439     }
48440   }
48441
48442 }
48443
48444
48445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
48446   void * jresult ;
48447   Dali::Rect< float > *result = 0 ;
48448
48449   {
48450     try {
48451       result = (Dali::Rect< float > *)new Dali::Rect< float >();
48452     } catch (std::out_of_range& e) {
48453       {
48454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48455       };
48456     } catch (std::exception& e) {
48457       {
48458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48459       };
48460     } catch (Dali::DaliException e) {
48461       {
48462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48463       };
48464     } catch (...) {
48465       {
48466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48467       };
48468     }
48469   }
48470
48471   jresult = (void *)result;
48472   return jresult;
48473 }
48474
48475
48476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
48477   void * jresult ;
48478   float arg1 ;
48479   float arg2 ;
48480   float arg3 ;
48481   float arg4 ;
48482   Dali::Rect< float > *result = 0 ;
48483
48484   arg1 = (float)jarg1;
48485   arg2 = (float)jarg2;
48486   arg3 = (float)jarg4;
48487   arg4 = (float)jarg3;
48488   {
48489     try {
48490       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
48491     } catch (std::out_of_range& e) {
48492       {
48493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48494       };
48495     } catch (std::exception& e) {
48496       {
48497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48498       };
48499     } catch (Dali::DaliException e) {
48500       {
48501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48502       };
48503     } catch (...) {
48504       {
48505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48506       };
48507     }
48508   }
48509
48510   jresult = (void *)result;
48511   return jresult;
48512 }
48513
48514
48515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
48516   void * jresult ;
48517   Dali::Rect< float > *arg1 = 0 ;
48518   Dali::Rect< float > *result = 0 ;
48519
48520   arg1 = (Dali::Rect< float > *)jarg1;
48521   if (!arg1) {
48522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
48523     return 0;
48524   }
48525   {
48526     try {
48527       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
48528     } catch (std::out_of_range& e) {
48529       {
48530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48531       };
48532     } catch (std::exception& e) {
48533       {
48534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48535       };
48536     } catch (Dali::DaliException e) {
48537       {
48538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48539       };
48540     } catch (...) {
48541       {
48542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48543       };
48544     }
48545   }
48546
48547   jresult = (void *)result;
48548   return jresult;
48549 }
48550
48551
48552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
48553   void * jresult ;
48554   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48555   Dali::Rect< float > *arg2 = 0 ;
48556   Dali::Rect< float > *result = 0 ;
48557
48558   arg1 = (Dali::Rect< float > *)jarg1;
48559   arg2 = (Dali::Rect< float > *)jarg2;
48560   if (!arg2) {
48561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
48562     return 0;
48563   }
48564   {
48565     try {
48566       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
48567     } catch (std::out_of_range& e) {
48568       {
48569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48570       };
48571     } catch (std::exception& e) {
48572       {
48573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48574       };
48575     } catch (Dali::DaliException e) {
48576       {
48577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48578       };
48579     } catch (...) {
48580       {
48581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48582       };
48583     }
48584   }
48585
48586   jresult = (void *)result;
48587   return jresult;
48588 }
48589
48590
48591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
48592   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48593   float arg2 ;
48594   float arg3 ;
48595   float arg4 ;
48596   float arg5 ;
48597
48598   arg1 = (Dali::Rect< float > *)jarg1;
48599   arg2 = (float)jarg2;
48600   arg3 = (float)jarg3;
48601   arg4 = (float)jarg5;
48602   arg5 = (float)jarg4;
48603   {
48604     try {
48605       (arg1)->Set(arg2,arg3,arg4,arg5);
48606     } catch (std::out_of_range& e) {
48607       {
48608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48609       };
48610     } catch (std::exception& e) {
48611       {
48612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48613       };
48614     } catch (Dali::DaliException e) {
48615       {
48616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48617       };
48618     } catch (...) {
48619       {
48620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48621       };
48622     }
48623   }
48624
48625 }
48626
48627
48628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
48629   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48630   float arg2 ;
48631
48632   arg1 = (Dali::Rect< float > *)jarg1;
48633   arg2 = (float)jarg2;
48634   if (arg1) (arg1)->left = arg2;
48635 }
48636
48637
48638 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
48639   float jresult ;
48640   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48641   float result;
48642
48643   arg1 = (Dali::Rect< float > *)jarg1;
48644   result = (float) ((arg1)->left);
48645   jresult = result;
48646   return jresult;
48647 }
48648
48649
48650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
48651   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48652   float arg2 ;
48653
48654   arg1 = (Dali::Rect< float > *)jarg1;
48655   arg2 = (float)jarg2;
48656   if (arg1) (arg1)->left = arg2;
48657 }
48658
48659
48660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
48661   float jresult ;
48662   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48663   float result;
48664
48665   arg1 = (Dali::Rect< float > *)jarg1;
48666   result = (float) ((arg1)->left);
48667   jresult = result;
48668   return jresult;
48669 }
48670
48671
48672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
48673   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48674   float arg2 ;
48675
48676   arg1 = (Dali::Rect< float > *)jarg1;
48677   arg2 = (float)jarg2;
48678   if (arg1) (arg1)->right = arg2;
48679 }
48680
48681
48682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
48683   float jresult ;
48684   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48685   float result;
48686
48687   arg1 = (Dali::Rect< float > *)jarg1;
48688   result = (float) ((arg1)->right);
48689   jresult = result;
48690   return jresult;
48691 }
48692
48693
48694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
48695   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48696   float arg2 ;
48697
48698   arg1 = (Dali::Rect< float > *)jarg1;
48699   arg2 = (float)jarg2;
48700   if (arg1) (arg1)->right = arg2;
48701 }
48702
48703
48704 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
48705   float jresult ;
48706   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48707   float result;
48708
48709   arg1 = (Dali::Rect< float > *)jarg1;
48710   result = (float) ((arg1)->right);
48711   jresult = result;
48712   return jresult;
48713 }
48714
48715
48716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
48717   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48718   float arg2 ;
48719
48720   arg1 = (Dali::Rect< float > *)jarg1;
48721   arg2 = (float)jarg2;
48722   if (arg1) (arg1)->bottom = arg2;
48723 }
48724
48725
48726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
48727   float jresult ;
48728   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48729   float result;
48730
48731   arg1 = (Dali::Rect< float > *)jarg1;
48732   result = (float) ((arg1)->bottom);
48733   jresult = result;
48734   return jresult;
48735 }
48736
48737
48738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
48739   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48740   float arg2 ;
48741
48742   arg1 = (Dali::Rect< float > *)jarg1;
48743   arg2 = (float)jarg2;
48744   if (arg1) (arg1)->top = arg2;
48745 }
48746
48747
48748 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
48749   float jresult ;
48750   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48751   float result;
48752
48753   arg1 = (Dali::Rect< float > *)jarg1;
48754   result = (float) ((arg1)->top);
48755   jresult = result;
48756   return jresult;
48757 }
48758
48759
48760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
48761   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48762
48763   arg1 = (Dali::Rect< float > *)jarg1;
48764   {
48765     try {
48766       delete arg1;
48767     } catch (std::out_of_range& e) {
48768       {
48769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48770       };
48771     } catch (std::exception& e) {
48772       {
48773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48774       };
48775     } catch (Dali::DaliException e) {
48776       {
48777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48778       };
48779     } catch (...) {
48780       {
48781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48782       };
48783     }
48784   }
48785
48786 }
48787
48788
48789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
48790   int jresult ;
48791   int result;
48792
48793   result = (int)Dali::Vector< int >::BaseType;
48794   jresult = (int)result;
48795   return jresult;
48796 }
48797
48798
48799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
48800   void * jresult ;
48801   Dali::Vector< int > *result = 0 ;
48802
48803   {
48804     try {
48805       result = (Dali::Vector< int > *)new Dali::Vector< int >();
48806     } catch (std::out_of_range& e) {
48807       {
48808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48809       };
48810     } catch (std::exception& e) {
48811       {
48812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48813       };
48814     } catch (Dali::DaliException e) {
48815       {
48816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48817       };
48818     } catch (...) {
48819       {
48820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48821       };
48822     }
48823   }
48824
48825   jresult = (void *)result;
48826   return jresult;
48827 }
48828
48829
48830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
48831   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48832
48833   arg1 = (Dali::Vector< int > *)jarg1;
48834   {
48835     try {
48836       delete arg1;
48837     } catch (std::out_of_range& e) {
48838       {
48839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48840       };
48841     } catch (std::exception& e) {
48842       {
48843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48844       };
48845     } catch (Dali::DaliException e) {
48846       {
48847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48848       };
48849     } catch (...) {
48850       {
48851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48852       };
48853     }
48854   }
48855
48856 }
48857
48858
48859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
48860   void * jresult ;
48861   Dali::Vector< int > *arg1 = 0 ;
48862   Dali::Vector< int > *result = 0 ;
48863
48864   arg1 = (Dali::Vector< int > *)jarg1;
48865   if (!arg1) {
48866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
48867     return 0;
48868   }
48869   {
48870     try {
48871       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
48872     } catch (std::out_of_range& e) {
48873       {
48874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48875       };
48876     } catch (std::exception& e) {
48877       {
48878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48879       };
48880     } catch (Dali::DaliException e) {
48881       {
48882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48883       };
48884     } catch (...) {
48885       {
48886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48887       };
48888     }
48889   }
48890
48891   jresult = (void *)result;
48892   return jresult;
48893 }
48894
48895
48896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
48897   void * jresult ;
48898   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48899   Dali::Vector< int > *arg2 = 0 ;
48900   Dali::Vector< int > *result = 0 ;
48901
48902   arg1 = (Dali::Vector< int > *)jarg1;
48903   arg2 = (Dali::Vector< int > *)jarg2;
48904   if (!arg2) {
48905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
48906     return 0;
48907   }
48908   {
48909     try {
48910       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
48911     } catch (std::out_of_range& e) {
48912       {
48913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48914       };
48915     } catch (std::exception& e) {
48916       {
48917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48918       };
48919     } catch (Dali::DaliException e) {
48920       {
48921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48922       };
48923     } catch (...) {
48924       {
48925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48926       };
48927     }
48928   }
48929
48930   jresult = (void *)result;
48931   return jresult;
48932 }
48933
48934
48935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
48936   void * jresult ;
48937   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48938   Dali::Vector< int >::Iterator result;
48939
48940   arg1 = (Dali::Vector< int > *)jarg1;
48941   {
48942     try {
48943       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
48944     } catch (std::out_of_range& e) {
48945       {
48946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48947       };
48948     } catch (std::exception& e) {
48949       {
48950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48951       };
48952     } catch (Dali::DaliException e) {
48953       {
48954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48955       };
48956     } catch (...) {
48957       {
48958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48959       };
48960     }
48961   }
48962
48963   jresult = (void *)result;
48964   return jresult;
48965 }
48966
48967
48968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
48969   void * jresult ;
48970   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48971   Dali::Vector< int >::Iterator result;
48972
48973   arg1 = (Dali::Vector< int > *)jarg1;
48974   {
48975     try {
48976       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
48977     } catch (std::out_of_range& e) {
48978       {
48979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48980       };
48981     } catch (std::exception& e) {
48982       {
48983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48984       };
48985     } catch (Dali::DaliException e) {
48986       {
48987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48988       };
48989     } catch (...) {
48990       {
48991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48992       };
48993     }
48994   }
48995
48996   jresult = (void *)result;
48997   return jresult;
48998 }
48999
49000
49001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49002   void * jresult ;
49003   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49004   Dali::Vector< int >::SizeType arg2 ;
49005   Dali::Vector< int >::ItemType *result = 0 ;
49006
49007   arg1 = (Dali::Vector< int > *)jarg1;
49008   arg2 = (Dali::Vector< int >::SizeType)jarg2;
49009   {
49010     try {
49011       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
49012     } catch (std::out_of_range& e) {
49013       {
49014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49015       };
49016     } catch (std::exception& e) {
49017       {
49018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49019       };
49020     } catch (Dali::DaliException e) {
49021       {
49022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49023       };
49024     } catch (...) {
49025       {
49026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49027       };
49028     }
49029   }
49030
49031   jresult = (void *)result;
49032   return jresult;
49033 }
49034
49035
49036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
49037   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49038   Dali::Vector< int >::ItemType *arg2 = 0 ;
49039   Dali::Vector< int >::ItemType temp2 ;
49040
49041   arg1 = (Dali::Vector< int > *)jarg1;
49042   temp2 = (Dali::Vector< int >::ItemType)jarg2;
49043   arg2 = &temp2;
49044   {
49045     try {
49046       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
49047     } catch (std::out_of_range& e) {
49048       {
49049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49050       };
49051     } catch (std::exception& e) {
49052       {
49053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49054       };
49055     } catch (Dali::DaliException e) {
49056       {
49057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49058       };
49059     } catch (...) {
49060       {
49061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49062       };
49063     }
49064   }
49065
49066 }
49067
49068
49069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
49070   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49071   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
49072   Dali::Vector< int >::ItemType *arg3 = 0 ;
49073   Dali::Vector< int >::ItemType temp3 ;
49074
49075   arg1 = (Dali::Vector< int > *)jarg1;
49076   arg2 = (Dali::Vector< int >::Iterator)jarg2;
49077   temp3 = (Dali::Vector< int >::ItemType)jarg3;
49078   arg3 = &temp3;
49079   {
49080     try {
49081       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
49082     } catch (std::out_of_range& e) {
49083       {
49084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49085       };
49086     } catch (std::exception& e) {
49087       {
49088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49089       };
49090     } catch (Dali::DaliException e) {
49091       {
49092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49093       };
49094     } catch (...) {
49095       {
49096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49097       };
49098     }
49099   }
49100
49101 }
49102
49103
49104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49105   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49106   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
49107   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
49108   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
49109
49110   arg1 = (Dali::Vector< int > *)jarg1;
49111   arg2 = (Dali::Vector< int >::Iterator)jarg2;
49112   arg3 = (Dali::Vector< int >::Iterator)jarg3;
49113   arg4 = (Dali::Vector< int >::Iterator)jarg4;
49114   {
49115     try {
49116       (arg1)->Insert(arg2,arg3,arg4);
49117     } catch (std::out_of_range& e) {
49118       {
49119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49120       };
49121     } catch (std::exception& e) {
49122       {
49123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49124       };
49125     } catch (Dali::DaliException e) {
49126       {
49127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49128       };
49129     } catch (...) {
49130       {
49131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49132       };
49133     }
49134   }
49135
49136 }
49137
49138
49139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
49140   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49141   Dali::Vector< int >::SizeType arg2 ;
49142
49143   arg1 = (Dali::Vector< int > *)jarg1;
49144   arg2 = (Dali::Vector< int >::SizeType)jarg2;
49145   {
49146     try {
49147       (arg1)->Reserve(arg2);
49148     } catch (std::out_of_range& e) {
49149       {
49150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49151       };
49152     } catch (std::exception& e) {
49153       {
49154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49155       };
49156     } catch (Dali::DaliException e) {
49157       {
49158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49159       };
49160     } catch (...) {
49161       {
49162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49163       };
49164     }
49165   }
49166
49167 }
49168
49169
49170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49171   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49172   Dali::Vector< int >::SizeType arg2 ;
49173
49174   arg1 = (Dali::Vector< int > *)jarg1;
49175   arg2 = (Dali::Vector< int >::SizeType)jarg2;
49176   {
49177     try {
49178       (arg1)->Resize(arg2);
49179     } catch (std::out_of_range& e) {
49180       {
49181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49182       };
49183     } catch (std::exception& e) {
49184       {
49185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49186       };
49187     } catch (Dali::DaliException e) {
49188       {
49189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49190       };
49191     } catch (...) {
49192       {
49193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49194       };
49195     }
49196   }
49197
49198 }
49199
49200
49201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
49202   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49203   Dali::Vector< int >::SizeType arg2 ;
49204   Dali::Vector< int >::ItemType *arg3 = 0 ;
49205   Dali::Vector< int >::ItemType temp3 ;
49206
49207   arg1 = (Dali::Vector< int > *)jarg1;
49208   arg2 = (Dali::Vector< int >::SizeType)jarg2;
49209   temp3 = (Dali::Vector< int >::ItemType)jarg3;
49210   arg3 = &temp3;
49211   {
49212     try {
49213       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
49214     } catch (std::out_of_range& e) {
49215       {
49216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49217       };
49218     } catch (std::exception& e) {
49219       {
49220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49221       };
49222     } catch (Dali::DaliException e) {
49223       {
49224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49225       };
49226     } catch (...) {
49227       {
49228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49229       };
49230     }
49231   }
49232
49233 }
49234
49235
49236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
49237   void * jresult ;
49238   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49239   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
49240   Dali::Vector< int >::Iterator result;
49241
49242   arg1 = (Dali::Vector< int > *)jarg1;
49243   arg2 = (Dali::Vector< int >::Iterator)jarg2;
49244   {
49245     try {
49246       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
49247     } catch (std::out_of_range& e) {
49248       {
49249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49250       };
49251     } catch (std::exception& e) {
49252       {
49253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49254       };
49255     } catch (Dali::DaliException e) {
49256       {
49257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49258       };
49259     } catch (...) {
49260       {
49261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49262       };
49263     }
49264   }
49265
49266   jresult = (void *)result;
49267   return jresult;
49268 }
49269
49270
49271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
49272   void * jresult ;
49273   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49274   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
49275   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
49276   Dali::Vector< int >::Iterator result;
49277
49278   arg1 = (Dali::Vector< int > *)jarg1;
49279   arg2 = (Dali::Vector< int >::Iterator)jarg2;
49280   arg3 = (Dali::Vector< int >::Iterator)jarg3;
49281   {
49282     try {
49283       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
49284     } catch (std::out_of_range& e) {
49285       {
49286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49287       };
49288     } catch (std::exception& e) {
49289       {
49290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49291       };
49292     } catch (Dali::DaliException e) {
49293       {
49294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49295       };
49296     } catch (...) {
49297       {
49298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49299       };
49300     }
49301   }
49302
49303   jresult = (void *)result;
49304   return jresult;
49305 }
49306
49307
49308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
49309   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49310   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
49311
49312   arg1 = (Dali::Vector< int > *)jarg1;
49313   arg2 = (Dali::Vector< int >::Iterator)jarg2;
49314   {
49315     try {
49316       (arg1)->Remove(arg2);
49317     } catch (std::out_of_range& e) {
49318       {
49319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49320       };
49321     } catch (std::exception& e) {
49322       {
49323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49324       };
49325     } catch (Dali::DaliException e) {
49326       {
49327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49328       };
49329     } catch (...) {
49330       {
49331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49332       };
49333     }
49334   }
49335
49336 }
49337
49338
49339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
49340   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49341   Dali::Vector< int > *arg2 = 0 ;
49342
49343   arg1 = (Dali::Vector< int > *)jarg1;
49344   arg2 = (Dali::Vector< int > *)jarg2;
49345   if (!arg2) {
49346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
49347     return ;
49348   }
49349   {
49350     try {
49351       (arg1)->Swap(*arg2);
49352     } catch (std::out_of_range& e) {
49353       {
49354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49355       };
49356     } catch (std::exception& e) {
49357       {
49358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49359       };
49360     } catch (Dali::DaliException e) {
49361       {
49362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49363       };
49364     } catch (...) {
49365       {
49366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49367       };
49368     }
49369   }
49370
49371 }
49372
49373
49374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
49375   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49376
49377   arg1 = (Dali::Vector< int > *)jarg1;
49378   {
49379     try {
49380       (arg1)->Clear();
49381     } catch (std::out_of_range& e) {
49382       {
49383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49384       };
49385     } catch (std::exception& e) {
49386       {
49387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49388       };
49389     } catch (Dali::DaliException e) {
49390       {
49391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49392       };
49393     } catch (...) {
49394       {
49395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49396       };
49397     }
49398   }
49399
49400 }
49401
49402
49403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
49404   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49405
49406   arg1 = (Dali::Vector< int > *)jarg1;
49407   {
49408     try {
49409       (arg1)->Release();
49410     } catch (std::out_of_range& e) {
49411       {
49412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49413       };
49414     } catch (std::exception& e) {
49415       {
49416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49417       };
49418     } catch (Dali::DaliException e) {
49419       {
49420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49421       };
49422     } catch (...) {
49423       {
49424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49425       };
49426     }
49427   }
49428
49429 }
49430
49431
49432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
49433   int jresult ;
49434   int result;
49435
49436   result = (int)Dali::Vector< float >::BaseType;
49437   jresult = (int)result;
49438   return jresult;
49439 }
49440
49441
49442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
49443   void * jresult ;
49444   Dali::Vector< float > *result = 0 ;
49445
49446   {
49447     try {
49448       result = (Dali::Vector< float > *)new Dali::Vector< float >();
49449     } catch (std::out_of_range& e) {
49450       {
49451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49452       };
49453     } catch (std::exception& e) {
49454       {
49455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49456       };
49457     } catch (Dali::DaliException e) {
49458       {
49459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49460       };
49461     } catch (...) {
49462       {
49463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49464       };
49465     }
49466   }
49467
49468   jresult = (void *)result;
49469   return jresult;
49470 }
49471
49472
49473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
49474   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49475
49476   arg1 = (Dali::Vector< float > *)jarg1;
49477   {
49478     try {
49479       delete arg1;
49480     } catch (std::out_of_range& e) {
49481       {
49482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49483       };
49484     } catch (std::exception& e) {
49485       {
49486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49487       };
49488     } catch (Dali::DaliException e) {
49489       {
49490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49491       };
49492     } catch (...) {
49493       {
49494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49495       };
49496     }
49497   }
49498
49499 }
49500
49501
49502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
49503   void * jresult ;
49504   Dali::Vector< float > *arg1 = 0 ;
49505   Dali::Vector< float > *result = 0 ;
49506
49507   arg1 = (Dali::Vector< float > *)jarg1;
49508   if (!arg1) {
49509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
49510     return 0;
49511   }
49512   {
49513     try {
49514       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
49515     } catch (std::out_of_range& e) {
49516       {
49517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49518       };
49519     } catch (std::exception& e) {
49520       {
49521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49522       };
49523     } catch (Dali::DaliException e) {
49524       {
49525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49526       };
49527     } catch (...) {
49528       {
49529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49530       };
49531     }
49532   }
49533
49534   jresult = (void *)result;
49535   return jresult;
49536 }
49537
49538
49539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
49540   void * jresult ;
49541   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49542   Dali::Vector< float > *arg2 = 0 ;
49543   Dali::Vector< float > *result = 0 ;
49544
49545   arg1 = (Dali::Vector< float > *)jarg1;
49546   arg2 = (Dali::Vector< float > *)jarg2;
49547   if (!arg2) {
49548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
49549     return 0;
49550   }
49551   {
49552     try {
49553       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
49554     } catch (std::out_of_range& e) {
49555       {
49556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49557       };
49558     } catch (std::exception& e) {
49559       {
49560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49561       };
49562     } catch (Dali::DaliException e) {
49563       {
49564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49565       };
49566     } catch (...) {
49567       {
49568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49569       };
49570     }
49571   }
49572
49573   jresult = (void *)result;
49574   return jresult;
49575 }
49576
49577
49578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
49579   void * jresult ;
49580   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49581   Dali::Vector< float >::Iterator result;
49582
49583   arg1 = (Dali::Vector< float > *)jarg1;
49584   {
49585     try {
49586       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
49587     } catch (std::out_of_range& e) {
49588       {
49589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49590       };
49591     } catch (std::exception& e) {
49592       {
49593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49594       };
49595     } catch (Dali::DaliException e) {
49596       {
49597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49598       };
49599     } catch (...) {
49600       {
49601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49602       };
49603     }
49604   }
49605
49606   jresult = (void *)result;
49607   return jresult;
49608 }
49609
49610
49611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
49612   void * jresult ;
49613   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49614   Dali::Vector< float >::Iterator result;
49615
49616   arg1 = (Dali::Vector< float > *)jarg1;
49617   {
49618     try {
49619       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
49620     } catch (std::out_of_range& e) {
49621       {
49622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49623       };
49624     } catch (std::exception& e) {
49625       {
49626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49627       };
49628     } catch (Dali::DaliException e) {
49629       {
49630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49631       };
49632     } catch (...) {
49633       {
49634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49635       };
49636     }
49637   }
49638
49639   jresult = (void *)result;
49640   return jresult;
49641 }
49642
49643
49644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49645   void * jresult ;
49646   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49647   Dali::Vector< float >::SizeType arg2 ;
49648   Dali::Vector< float >::ItemType *result = 0 ;
49649
49650   arg1 = (Dali::Vector< float > *)jarg1;
49651   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49652   {
49653     try {
49654       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
49655     } catch (std::out_of_range& e) {
49656       {
49657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49658       };
49659     } catch (std::exception& e) {
49660       {
49661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49662       };
49663     } catch (Dali::DaliException e) {
49664       {
49665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49666       };
49667     } catch (...) {
49668       {
49669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49670       };
49671     }
49672   }
49673
49674   jresult = (void *)result;
49675   return jresult;
49676 }
49677
49678
49679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
49680   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49681   Dali::Vector< float >::ItemType *arg2 = 0 ;
49682   Dali::Vector< float >::ItemType temp2 ;
49683
49684   arg1 = (Dali::Vector< float > *)jarg1;
49685   temp2 = (Dali::Vector< float >::ItemType)jarg2;
49686   arg2 = &temp2;
49687   {
49688     try {
49689       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
49690     } catch (std::out_of_range& e) {
49691       {
49692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49693       };
49694     } catch (std::exception& e) {
49695       {
49696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49697       };
49698     } catch (Dali::DaliException e) {
49699       {
49700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49701       };
49702     } catch (...) {
49703       {
49704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49705       };
49706     }
49707   }
49708
49709 }
49710
49711
49712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
49713   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49714   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49715   Dali::Vector< float >::ItemType *arg3 = 0 ;
49716   Dali::Vector< float >::ItemType temp3 ;
49717
49718   arg1 = (Dali::Vector< float > *)jarg1;
49719   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49720   temp3 = (Dali::Vector< float >::ItemType)jarg3;
49721   arg3 = &temp3;
49722   {
49723     try {
49724       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
49725     } catch (std::out_of_range& e) {
49726       {
49727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49728       };
49729     } catch (std::exception& e) {
49730       {
49731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49732       };
49733     } catch (Dali::DaliException e) {
49734       {
49735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49736       };
49737     } catch (...) {
49738       {
49739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49740       };
49741     }
49742   }
49743
49744 }
49745
49746
49747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49748   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49749   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49750   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
49751   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
49752
49753   arg1 = (Dali::Vector< float > *)jarg1;
49754   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49755   arg3 = (Dali::Vector< float >::Iterator)jarg3;
49756   arg4 = (Dali::Vector< float >::Iterator)jarg4;
49757   {
49758     try {
49759       (arg1)->Insert(arg2,arg3,arg4);
49760     } catch (std::out_of_range& e) {
49761       {
49762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49763       };
49764     } catch (std::exception& e) {
49765       {
49766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49767       };
49768     } catch (Dali::DaliException e) {
49769       {
49770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49771       };
49772     } catch (...) {
49773       {
49774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49775       };
49776     }
49777   }
49778
49779 }
49780
49781
49782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
49783   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49784   Dali::Vector< float >::SizeType arg2 ;
49785
49786   arg1 = (Dali::Vector< float > *)jarg1;
49787   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49788   {
49789     try {
49790       (arg1)->Reserve(arg2);
49791     } catch (std::out_of_range& e) {
49792       {
49793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49794       };
49795     } catch (std::exception& e) {
49796       {
49797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49798       };
49799     } catch (Dali::DaliException e) {
49800       {
49801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49802       };
49803     } catch (...) {
49804       {
49805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49806       };
49807     }
49808   }
49809
49810 }
49811
49812 //// ========================= end of part 2 =============================
49813
49814 //// ========================== start part 3 ===============================
49815
49816
49817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49818   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49819   Dali::Vector< float >::SizeType arg2 ;
49820
49821   arg1 = (Dali::Vector< float > *)jarg1;
49822   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49823   {
49824     try {
49825       (arg1)->Resize(arg2);
49826     } catch (std::out_of_range& e) {
49827       {
49828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49829       };
49830     } catch (std::exception& e) {
49831       {
49832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49833       };
49834     } catch (Dali::DaliException e) {
49835       {
49836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49837       };
49838     } catch (...) {
49839       {
49840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49841       };
49842     }
49843   }
49844
49845 }
49846
49847
49848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
49849   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49850   Dali::Vector< float >::SizeType arg2 ;
49851   Dali::Vector< float >::ItemType *arg3 = 0 ;
49852   Dali::Vector< float >::ItemType temp3 ;
49853
49854   arg1 = (Dali::Vector< float > *)jarg1;
49855   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49856   temp3 = (Dali::Vector< float >::ItemType)jarg3;
49857   arg3 = &temp3;
49858   {
49859     try {
49860       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
49861     } catch (std::out_of_range& e) {
49862       {
49863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49864       };
49865     } catch (std::exception& e) {
49866       {
49867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49868       };
49869     } catch (Dali::DaliException e) {
49870       {
49871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49872       };
49873     } catch (...) {
49874       {
49875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49876       };
49877     }
49878   }
49879
49880 }
49881
49882
49883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
49884   void * jresult ;
49885   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49886   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49887   Dali::Vector< float >::Iterator result;
49888
49889   arg1 = (Dali::Vector< float > *)jarg1;
49890   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49891   {
49892     try {
49893       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
49894     } catch (std::out_of_range& e) {
49895       {
49896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49897       };
49898     } catch (std::exception& e) {
49899       {
49900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49901       };
49902     } catch (Dali::DaliException e) {
49903       {
49904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49905       };
49906     } catch (...) {
49907       {
49908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49909       };
49910     }
49911   }
49912
49913   jresult = (void *)result;
49914   return jresult;
49915 }
49916
49917
49918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
49919   void * jresult ;
49920   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49921   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49922   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
49923   Dali::Vector< float >::Iterator result;
49924
49925   arg1 = (Dali::Vector< float > *)jarg1;
49926   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49927   arg3 = (Dali::Vector< float >::Iterator)jarg3;
49928   {
49929     try {
49930       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
49931     } catch (std::out_of_range& e) {
49932       {
49933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49934       };
49935     } catch (std::exception& e) {
49936       {
49937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49938       };
49939     } catch (Dali::DaliException e) {
49940       {
49941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49942       };
49943     } catch (...) {
49944       {
49945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49946       };
49947     }
49948   }
49949
49950   jresult = (void *)result;
49951   return jresult;
49952 }
49953
49954
49955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
49956   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49957   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49958
49959   arg1 = (Dali::Vector< float > *)jarg1;
49960   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49961   {
49962     try {
49963       (arg1)->Remove(arg2);
49964     } catch (std::out_of_range& e) {
49965       {
49966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49967       };
49968     } catch (std::exception& e) {
49969       {
49970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49971       };
49972     } catch (Dali::DaliException e) {
49973       {
49974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49975       };
49976     } catch (...) {
49977       {
49978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49979       };
49980     }
49981   }
49982
49983 }
49984
49985
49986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
49987   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49988   Dali::Vector< float > *arg2 = 0 ;
49989
49990   arg1 = (Dali::Vector< float > *)jarg1;
49991   arg2 = (Dali::Vector< float > *)jarg2;
49992   if (!arg2) {
49993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
49994     return ;
49995   }
49996   {
49997     try {
49998       (arg1)->Swap(*arg2);
49999     } catch (std::out_of_range& e) {
50000       {
50001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50002       };
50003     } catch (std::exception& e) {
50004       {
50005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50006       };
50007     } catch (Dali::DaliException e) {
50008       {
50009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50010       };
50011     } catch (...) {
50012       {
50013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50014       };
50015     }
50016   }
50017
50018 }
50019
50020
50021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
50022   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50023
50024   arg1 = (Dali::Vector< float > *)jarg1;
50025   {
50026     try {
50027       (arg1)->Clear();
50028     } catch (std::out_of_range& e) {
50029       {
50030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50031       };
50032     } catch (std::exception& e) {
50033       {
50034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50035       };
50036     } catch (Dali::DaliException e) {
50037       {
50038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50039       };
50040     } catch (...) {
50041       {
50042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50043       };
50044     }
50045   }
50046
50047 }
50048
50049
50050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
50051   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50052
50053   arg1 = (Dali::Vector< float > *)jarg1;
50054   {
50055     try {
50056       (arg1)->Release();
50057     } catch (std::out_of_range& e) {
50058       {
50059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50060       };
50061     } catch (std::exception& e) {
50062       {
50063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50064       };
50065     } catch (Dali::DaliException e) {
50066       {
50067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50068       };
50069     } catch (...) {
50070       {
50071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50072       };
50073     }
50074   }
50075
50076 }
50077
50078
50079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
50080   int jresult ;
50081   int result;
50082
50083   result = (int)Dali::Vector< unsigned char >::BaseType;
50084   jresult = (int)result;
50085   return jresult;
50086 }
50087
50088
50089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
50090   void * jresult ;
50091   Dali::Vector< unsigned char > *result = 0 ;
50092
50093   {
50094     try {
50095       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
50096     } catch (std::out_of_range& e) {
50097       {
50098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50099       };
50100     } catch (std::exception& e) {
50101       {
50102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50103       };
50104     } catch (Dali::DaliException e) {
50105       {
50106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50107       };
50108     } catch (...) {
50109       {
50110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50111       };
50112     }
50113   }
50114
50115   jresult = (void *)result;
50116   return jresult;
50117 }
50118
50119
50120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
50121   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50122
50123   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50124   {
50125     try {
50126       delete arg1;
50127     } catch (std::out_of_range& e) {
50128       {
50129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50130       };
50131     } catch (std::exception& e) {
50132       {
50133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50134       };
50135     } catch (Dali::DaliException e) {
50136       {
50137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50138       };
50139     } catch (...) {
50140       {
50141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50142       };
50143     }
50144   }
50145
50146 }
50147
50148
50149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
50150   void * jresult ;
50151   Dali::Vector< unsigned char > *arg1 = 0 ;
50152   Dali::Vector< unsigned char > *result = 0 ;
50153
50154   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50155   if (!arg1) {
50156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
50157     return 0;
50158   }
50159   {
50160     try {
50161       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
50162     } catch (std::out_of_range& e) {
50163       {
50164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50165       };
50166     } catch (std::exception& e) {
50167       {
50168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50169       };
50170     } catch (Dali::DaliException e) {
50171       {
50172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50173       };
50174     } catch (...) {
50175       {
50176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50177       };
50178     }
50179   }
50180
50181   jresult = (void *)result;
50182   return jresult;
50183 }
50184
50185
50186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
50187   void * jresult ;
50188   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50189   Dali::Vector< unsigned char > *arg2 = 0 ;
50190   Dali::Vector< unsigned char > *result = 0 ;
50191
50192   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50193   arg2 = (Dali::Vector< unsigned char > *)jarg2;
50194   if (!arg2) {
50195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
50196     return 0;
50197   }
50198   {
50199     try {
50200       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
50201     } catch (std::out_of_range& e) {
50202       {
50203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50204       };
50205     } catch (std::exception& e) {
50206       {
50207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50208       };
50209     } catch (Dali::DaliException e) {
50210       {
50211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50212       };
50213     } catch (...) {
50214       {
50215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50216       };
50217     }
50218   }
50219
50220   jresult = (void *)result;
50221   return jresult;
50222 }
50223
50224
50225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
50226   void * jresult ;
50227   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50228   Dali::Vector< unsigned char >::Iterator result;
50229
50230   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50231   {
50232     try {
50233       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
50234     } catch (std::out_of_range& e) {
50235       {
50236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50237       };
50238     } catch (std::exception& e) {
50239       {
50240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50241       };
50242     } catch (Dali::DaliException e) {
50243       {
50244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50245       };
50246     } catch (...) {
50247       {
50248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50249       };
50250     }
50251   }
50252
50253   jresult = (void *)result;
50254   return jresult;
50255 }
50256
50257
50258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
50259   void * jresult ;
50260   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50261   Dali::Vector< unsigned char >::Iterator result;
50262
50263   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50264   {
50265     try {
50266       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
50267     } catch (std::out_of_range& e) {
50268       {
50269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50270       };
50271     } catch (std::exception& e) {
50272       {
50273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50274       };
50275     } catch (Dali::DaliException e) {
50276       {
50277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50278       };
50279     } catch (...) {
50280       {
50281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50282       };
50283     }
50284   }
50285
50286   jresult = (void *)result;
50287   return jresult;
50288 }
50289
50290
50291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
50292   void * jresult ;
50293   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50294   Dali::Vector< unsigned char >::SizeType arg2 ;
50295   Dali::Vector< unsigned char >::ItemType *result = 0 ;
50296
50297   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50298   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
50299   {
50300     try {
50301       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
50302     } catch (std::out_of_range& e) {
50303       {
50304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50305       };
50306     } catch (std::exception& e) {
50307       {
50308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50309       };
50310     } catch (Dali::DaliException e) {
50311       {
50312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50313       };
50314     } catch (...) {
50315       {
50316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50317       };
50318     }
50319   }
50320
50321   jresult = (void *)result;
50322   return jresult;
50323 }
50324
50325
50326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
50327   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50328   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
50329   Dali::Vector< unsigned char >::ItemType temp2 ;
50330
50331   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50332   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
50333   arg2 = &temp2;
50334   {
50335     try {
50336       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
50337     } catch (std::out_of_range& e) {
50338       {
50339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50340       };
50341     } catch (std::exception& e) {
50342       {
50343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50344       };
50345     } catch (Dali::DaliException e) {
50346       {
50347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50348       };
50349     } catch (...) {
50350       {
50351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50352       };
50353     }
50354   }
50355
50356 }
50357
50358
50359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
50360   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50361   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
50362   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
50363   Dali::Vector< unsigned char >::ItemType temp3 ;
50364
50365   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50366   arg2 = jarg2;
50367   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
50368   arg3 = &temp3;
50369   {
50370     try {
50371       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
50372     } catch (std::out_of_range& e) {
50373       {
50374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50375       };
50376     } catch (std::exception& e) {
50377       {
50378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50379       };
50380     } catch (Dali::DaliException e) {
50381       {
50382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50383       };
50384     } catch (...) {
50385       {
50386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50387       };
50388     }
50389   }
50390
50391
50392
50393 }
50394
50395
50396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
50397   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50398   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
50399   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
50400   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
50401
50402   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50403   arg2 = jarg2;
50404   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
50405   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
50406   {
50407     try {
50408       (arg1)->Insert(arg2,arg3,arg4);
50409     } catch (std::out_of_range& e) {
50410       {
50411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50412       };
50413     } catch (std::exception& e) {
50414       {
50415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50416       };
50417     } catch (Dali::DaliException e) {
50418       {
50419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50420       };
50421     } catch (...) {
50422       {
50423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50424       };
50425     }
50426   }
50427
50428
50429
50430 }
50431
50432
50433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
50434   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50435   Dali::Vector< unsigned char >::SizeType arg2 ;
50436
50437   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50438   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
50439   {
50440     try {
50441       (arg1)->Reserve(arg2);
50442     } catch (std::out_of_range& e) {
50443       {
50444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50445       };
50446     } catch (std::exception& e) {
50447       {
50448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50449       };
50450     } catch (Dali::DaliException e) {
50451       {
50452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50453       };
50454     } catch (...) {
50455       {
50456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50457       };
50458     }
50459   }
50460
50461 }
50462
50463
50464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
50465   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50466   Dali::Vector< unsigned char >::SizeType arg2 ;
50467
50468   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50469   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
50470   {
50471     try {
50472       (arg1)->Resize(arg2);
50473     } catch (std::out_of_range& e) {
50474       {
50475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50476       };
50477     } catch (std::exception& e) {
50478       {
50479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50480       };
50481     } catch (Dali::DaliException e) {
50482       {
50483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50484       };
50485     } catch (...) {
50486       {
50487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50488       };
50489     }
50490   }
50491
50492 }
50493
50494
50495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
50496   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50497   Dali::Vector< unsigned char >::SizeType arg2 ;
50498   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
50499   Dali::Vector< unsigned char >::ItemType temp3 ;
50500
50501   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50502   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
50503   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
50504   arg3 = &temp3;
50505   {
50506     try {
50507       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
50508     } catch (std::out_of_range& e) {
50509       {
50510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50511       };
50512     } catch (std::exception& e) {
50513       {
50514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50515       };
50516     } catch (Dali::DaliException e) {
50517       {
50518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50519       };
50520     } catch (...) {
50521       {
50522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50523       };
50524     }
50525   }
50526
50527 }
50528
50529
50530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
50531   void * jresult ;
50532   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50533   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
50534   Dali::Vector< unsigned char >::Iterator result;
50535
50536   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50537   arg2 = jarg2;
50538   {
50539     try {
50540       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
50541     } catch (std::out_of_range& e) {
50542       {
50543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50544       };
50545     } catch (std::exception& e) {
50546       {
50547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50548       };
50549     } catch (Dali::DaliException e) {
50550       {
50551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50552       };
50553     } catch (...) {
50554       {
50555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50556       };
50557     }
50558   }
50559
50560   jresult = (void *)result;
50561
50562
50563   return jresult;
50564 }
50565
50566
50567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
50568   void * jresult ;
50569   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50570   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
50571   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
50572   Dali::Vector< unsigned char >::Iterator result;
50573
50574   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50575   arg2 = jarg2;
50576   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
50577   {
50578     try {
50579       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
50580     } catch (std::out_of_range& e) {
50581       {
50582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50583       };
50584     } catch (std::exception& e) {
50585       {
50586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50587       };
50588     } catch (Dali::DaliException e) {
50589       {
50590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50591       };
50592     } catch (...) {
50593       {
50594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50595       };
50596     }
50597   }
50598
50599   jresult = (void *)result;
50600
50601
50602   return jresult;
50603 }
50604
50605
50606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
50607   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50608   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
50609
50610   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50611   arg2 = jarg2;
50612   {
50613     try {
50614       (arg1)->Remove(arg2);
50615     } catch (std::out_of_range& e) {
50616       {
50617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50618       };
50619     } catch (std::exception& e) {
50620       {
50621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50622       };
50623     } catch (Dali::DaliException e) {
50624       {
50625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50626       };
50627     } catch (...) {
50628       {
50629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50630       };
50631     }
50632   }
50633
50634
50635
50636 }
50637
50638
50639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
50640   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50641   Dali::Vector< unsigned char > *arg2 = 0 ;
50642
50643   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50644   arg2 = (Dali::Vector< unsigned char > *)jarg2;
50645   if (!arg2) {
50646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
50647     return ;
50648   }
50649   {
50650     try {
50651       (arg1)->Swap(*arg2);
50652     } catch (std::out_of_range& e) {
50653       {
50654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50655       };
50656     } catch (std::exception& e) {
50657       {
50658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50659       };
50660     } catch (Dali::DaliException e) {
50661       {
50662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50663       };
50664     } catch (...) {
50665       {
50666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50667       };
50668     }
50669   }
50670
50671 }
50672
50673
50674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
50675   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50676
50677   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50678   {
50679     try {
50680       (arg1)->Clear();
50681     } catch (std::out_of_range& e) {
50682       {
50683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50684       };
50685     } catch (std::exception& e) {
50686       {
50687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50688       };
50689     } catch (Dali::DaliException e) {
50690       {
50691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50692       };
50693     } catch (...) {
50694       {
50695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50696       };
50697     }
50698   }
50699
50700 }
50701
50702
50703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
50704   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50705
50706   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50707   {
50708     try {
50709       (arg1)->Release();
50710     } catch (std::out_of_range& e) {
50711       {
50712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50713       };
50714     } catch (std::exception& e) {
50715       {
50716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50717       };
50718     } catch (Dali::DaliException e) {
50719       {
50720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50721       };
50722     } catch (...) {
50723       {
50724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50725       };
50726     }
50727   }
50728
50729 }
50730
50731
50732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
50733   int jresult ;
50734   int result;
50735
50736   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
50737   jresult = (int)result;
50738   return jresult;
50739 }
50740
50741
50742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
50743   void * jresult ;
50744   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
50745
50746   {
50747     try {
50748       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
50749     } catch (std::out_of_range& e) {
50750       {
50751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50752       };
50753     } catch (std::exception& e) {
50754       {
50755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50756       };
50757     } catch (Dali::DaliException e) {
50758       {
50759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50760       };
50761     } catch (...) {
50762       {
50763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50764       };
50765     }
50766   }
50767
50768   jresult = (void *)result;
50769   return jresult;
50770 }
50771
50772
50773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
50774   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50775
50776   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50777   {
50778     try {
50779       delete arg1;
50780     } catch (std::out_of_range& e) {
50781       {
50782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50783       };
50784     } catch (std::exception& e) {
50785       {
50786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50787       };
50788     } catch (Dali::DaliException e) {
50789       {
50790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50791       };
50792     } catch (...) {
50793       {
50794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50795       };
50796     }
50797   }
50798
50799 }
50800
50801
50802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
50803   void * jresult ;
50804   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
50805   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
50806
50807   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50808   if (!arg1) {
50809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
50810     return 0;
50811   }
50812   {
50813     try {
50814       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
50815     } catch (std::out_of_range& e) {
50816       {
50817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50818       };
50819     } catch (std::exception& e) {
50820       {
50821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50822       };
50823     } catch (Dali::DaliException e) {
50824       {
50825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50826       };
50827     } catch (...) {
50828       {
50829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50830       };
50831     }
50832   }
50833
50834   jresult = (void *)result;
50835   return jresult;
50836 }
50837
50838
50839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
50840   void * jresult ;
50841   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50842   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50843   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
50844
50845   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50846   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50847   if (!arg2) {
50848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
50849     return 0;
50850   }
50851   {
50852     try {
50853       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
50854     } catch (std::out_of_range& e) {
50855       {
50856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50857       };
50858     } catch (std::exception& e) {
50859       {
50860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50861       };
50862     } catch (Dali::DaliException e) {
50863       {
50864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50865       };
50866     } catch (...) {
50867       {
50868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50869       };
50870     }
50871   }
50872
50873   jresult = (void *)result;
50874   return jresult;
50875 }
50876
50877
50878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
50879   void * jresult ;
50880   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50881   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50882
50883   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50884   {
50885     try {
50886       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
50887     } catch (std::out_of_range& e) {
50888       {
50889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50890       };
50891     } catch (std::exception& e) {
50892       {
50893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50894       };
50895     } catch (Dali::DaliException e) {
50896       {
50897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50898       };
50899     } catch (...) {
50900       {
50901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50902       };
50903     }
50904   }
50905
50906   jresult = (void *)result;
50907   return jresult;
50908 }
50909
50910
50911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
50912   void * jresult ;
50913   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50914   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50915
50916   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50917   {
50918     try {
50919       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
50920     } catch (std::out_of_range& e) {
50921       {
50922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50923       };
50924     } catch (std::exception& e) {
50925       {
50926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50927       };
50928     } catch (Dali::DaliException e) {
50929       {
50930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50931       };
50932     } catch (...) {
50933       {
50934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50935       };
50936     }
50937   }
50938
50939   jresult = (void *)result;
50940   return jresult;
50941 }
50942
50943
50944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
50945   void * jresult ;
50946   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50947   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50948   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
50949
50950   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50951   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50952   {
50953     try {
50954       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
50955     } catch (std::out_of_range& e) {
50956       {
50957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50958       };
50959     } catch (std::exception& e) {
50960       {
50961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50962       };
50963     } catch (Dali::DaliException e) {
50964       {
50965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50966       };
50967     } catch (...) {
50968       {
50969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50970       };
50971     }
50972   }
50973
50974   jresult = (void *)result;
50975   return jresult;
50976 }
50977
50978
50979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
50980   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50981   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
50982
50983   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50984   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
50985   if (!arg2) {
50986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50987     return ;
50988   }
50989   {
50990     try {
50991       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
50992     } catch (std::out_of_range& e) {
50993       {
50994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50995       };
50996     } catch (std::exception& e) {
50997       {
50998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50999       };
51000     } catch (Dali::DaliException e) {
51001       {
51002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51003       };
51004     } catch (...) {
51005       {
51006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51007       };
51008     }
51009   }
51010
51011 }
51012
51013
51014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
51015   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51016   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
51017   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
51018
51019   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51020   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
51021   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
51022   if (!arg3) {
51023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
51024     return ;
51025   }
51026   {
51027     try {
51028       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
51029     } catch (std::out_of_range& e) {
51030       {
51031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51032       };
51033     } catch (std::exception& e) {
51034       {
51035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51036       };
51037     } catch (Dali::DaliException e) {
51038       {
51039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51040       };
51041     } catch (...) {
51042       {
51043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51044       };
51045     }
51046   }
51047
51048 }
51049
51050
51051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51052   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51053   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
51054   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
51055   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
51056
51057   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51058   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
51059   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
51060   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
51061   {
51062     try {
51063       (arg1)->Insert(arg2,arg3,arg4);
51064     } catch (std::out_of_range& e) {
51065       {
51066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51067       };
51068     } catch (std::exception& e) {
51069       {
51070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51071       };
51072     } catch (Dali::DaliException e) {
51073       {
51074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51075       };
51076     } catch (...) {
51077       {
51078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51079       };
51080     }
51081   }
51082
51083 }
51084
51085
51086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
51087   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51088   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
51089
51090   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51091   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
51092   {
51093     try {
51094       (arg1)->Reserve(arg2);
51095     } catch (std::out_of_range& e) {
51096       {
51097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51098       };
51099     } catch (std::exception& e) {
51100       {
51101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51102       };
51103     } catch (Dali::DaliException e) {
51104       {
51105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51106       };
51107     } catch (...) {
51108       {
51109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51110       };
51111     }
51112   }
51113
51114 }
51115
51116
51117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51118   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51119   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
51120
51121   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51122   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
51123   {
51124     try {
51125       (arg1)->Resize(arg2);
51126     } catch (std::out_of_range& e) {
51127       {
51128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51129       };
51130     } catch (std::exception& e) {
51131       {
51132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51133       };
51134     } catch (Dali::DaliException e) {
51135       {
51136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51137       };
51138     } catch (...) {
51139       {
51140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51141       };
51142     }
51143   }
51144
51145 }
51146
51147
51148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
51149   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51150   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
51151   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
51152
51153   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51154   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
51155   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
51156   if (!arg3) {
51157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
51158     return ;
51159   }
51160   {
51161     try {
51162       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
51163     } catch (std::out_of_range& e) {
51164       {
51165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51166       };
51167     } catch (std::exception& e) {
51168       {
51169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51170       };
51171     } catch (Dali::DaliException e) {
51172       {
51173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51174       };
51175     } catch (...) {
51176       {
51177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51178       };
51179     }
51180   }
51181
51182 }
51183
51184
51185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
51186   void * jresult ;
51187   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51188   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
51189   Dali::Vector< Dali::Uint16Pair >::Iterator result;
51190
51191   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51192   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
51193   {
51194     try {
51195       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
51196     } catch (std::out_of_range& e) {
51197       {
51198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51199       };
51200     } catch (std::exception& e) {
51201       {
51202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51203       };
51204     } catch (Dali::DaliException e) {
51205       {
51206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51207       };
51208     } catch (...) {
51209       {
51210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51211       };
51212     }
51213   }
51214
51215   jresult = (void *)result;
51216   return jresult;
51217 }
51218
51219
51220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51221   void * jresult ;
51222   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51223   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
51224   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
51225   Dali::Vector< Dali::Uint16Pair >::Iterator result;
51226
51227   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51228   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
51229   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
51230   {
51231     try {
51232       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
51233     } catch (std::out_of_range& e) {
51234       {
51235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51236       };
51237     } catch (std::exception& e) {
51238       {
51239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51240       };
51241     } catch (Dali::DaliException e) {
51242       {
51243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51244       };
51245     } catch (...) {
51246       {
51247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51248       };
51249     }
51250   }
51251
51252   jresult = (void *)result;
51253   return jresult;
51254 }
51255
51256
51257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
51258   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51259   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
51260
51261   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51262   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
51263   {
51264     try {
51265       (arg1)->Remove(arg2);
51266     } catch (std::out_of_range& e) {
51267       {
51268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51269       };
51270     } catch (std::exception& e) {
51271       {
51272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51273       };
51274     } catch (Dali::DaliException e) {
51275       {
51276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51277       };
51278     } catch (...) {
51279       {
51280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51281       };
51282     }
51283   }
51284
51285 }
51286
51287
51288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
51289   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51290   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
51291
51292   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51293   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
51294   if (!arg2) {
51295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
51296     return ;
51297   }
51298   {
51299     try {
51300       (arg1)->Swap(*arg2);
51301     } catch (std::out_of_range& e) {
51302       {
51303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51304       };
51305     } catch (std::exception& e) {
51306       {
51307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51308       };
51309     } catch (Dali::DaliException e) {
51310       {
51311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51312       };
51313     } catch (...) {
51314       {
51315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51316       };
51317     }
51318   }
51319
51320 }
51321
51322
51323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
51324   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51325
51326   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51327   {
51328     try {
51329       (arg1)->Clear();
51330     } catch (std::out_of_range& e) {
51331       {
51332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51333       };
51334     } catch (std::exception& e) {
51335       {
51336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51337       };
51338     } catch (Dali::DaliException e) {
51339       {
51340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51341       };
51342     } catch (...) {
51343       {
51344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51345       };
51346     }
51347   }
51348
51349 }
51350
51351
51352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
51353   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51354
51355   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51356   {
51357     try {
51358       (arg1)->Release();
51359     } catch (std::out_of_range& e) {
51360       {
51361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51362       };
51363     } catch (std::exception& e) {
51364       {
51365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51366       };
51367     } catch (Dali::DaliException e) {
51368       {
51369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51370       };
51371     } catch (...) {
51372       {
51373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51374       };
51375     }
51376   }
51377
51378 }
51379
51380
51381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
51382   void * jresult ;
51383   Dali::Signal< void () > *result = 0 ;
51384
51385   {
51386     try {
51387       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
51388     } catch (std::out_of_range& e) {
51389       {
51390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51391       };
51392     } catch (std::exception& e) {
51393       {
51394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51395       };
51396     } catch (Dali::DaliException e) {
51397       {
51398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51399       };
51400     } catch (...) {
51401       {
51402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51403       };
51404     }
51405   }
51406
51407   jresult = (void *)result;
51408   return jresult;
51409 }
51410
51411
51412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
51413   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
51414
51415   arg1 = (Dali::Signal< void () > *)jarg1;
51416   {
51417     try {
51418       delete arg1;
51419     } catch (std::out_of_range& e) {
51420       {
51421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51422       };
51423     } catch (std::exception& e) {
51424       {
51425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51426       };
51427     } catch (Dali::DaliException e) {
51428       {
51429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51430       };
51431     } catch (...) {
51432       {
51433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51434       };
51435     }
51436   }
51437
51438 }
51439
51440
51441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
51442   unsigned int jresult ;
51443   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
51444   bool result;
51445
51446   arg1 = (Dali::Signal< void () > *)jarg1;
51447   {
51448     try {
51449       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
51450     } catch (std::out_of_range& e) {
51451       {
51452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51453       };
51454     } catch (std::exception& e) {
51455       {
51456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51457       };
51458     } catch (Dali::DaliException e) {
51459       {
51460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51461       };
51462     } catch (...) {
51463       {
51464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51465       };
51466     }
51467   }
51468
51469   jresult = result;
51470   return jresult;
51471 }
51472
51473
51474 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
51475   unsigned long jresult ;
51476   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
51477   std::size_t result;
51478
51479   arg1 = (Dali::Signal< void () > *)jarg1;
51480   {
51481     try {
51482       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
51483     } catch (std::out_of_range& e) {
51484       {
51485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51486       };
51487     } catch (std::exception& e) {
51488       {
51489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51490       };
51491     } catch (Dali::DaliException e) {
51492       {
51493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51494       };
51495     } catch (...) {
51496       {
51497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51498       };
51499     }
51500   }
51501
51502   jresult = (unsigned long)result;
51503   return jresult;
51504 }
51505
51506
51507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
51508   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
51509   void (*arg2)() = (void (*)()) 0 ;
51510
51511   arg1 = (Dali::Signal< void () > *)jarg1;
51512   arg2 = (void (*)())jarg2;
51513   {
51514     try {
51515       (arg1)->Connect(arg2);
51516     } catch (std::out_of_range& e) {
51517       {
51518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51519       };
51520     } catch (std::exception& e) {
51521       {
51522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51523       };
51524     } catch (Dali::DaliException e) {
51525       {
51526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51527       };
51528     } catch (...) {
51529       {
51530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51531       };
51532     }
51533   }
51534
51535 }
51536
51537
51538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
51539   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
51540   void (*arg2)() = (void (*)()) 0 ;
51541
51542   arg1 = (Dali::Signal< void () > *)jarg1;
51543   arg2 = (void (*)())jarg2;
51544   {
51545     try {
51546       (arg1)->Disconnect(arg2);
51547     } catch (std::out_of_range& e) {
51548       {
51549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51550       };
51551     } catch (std::exception& e) {
51552       {
51553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51554       };
51555     } catch (Dali::DaliException e) {
51556       {
51557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51558       };
51559     } catch (...) {
51560       {
51561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51562       };
51563     }
51564   }
51565
51566 }
51567
51568
51569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
51570   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
51571   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
51572   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
51573
51574   arg1 = (Dali::Signal< void () > *)jarg1;
51575   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
51576   arg3 = (Dali::FunctorDelegate *)jarg3;
51577   {
51578     try {
51579       (arg1)->Connect(arg2,arg3);
51580     } catch (std::out_of_range& e) {
51581       {
51582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51583       };
51584     } catch (std::exception& e) {
51585       {
51586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51587       };
51588     } catch (Dali::DaliException e) {
51589       {
51590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51591       };
51592     } catch (...) {
51593       {
51594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51595       };
51596     }
51597   }
51598
51599 }
51600
51601
51602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
51603   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
51604
51605   arg1 = (Dali::Signal< void () > *)jarg1;
51606   {
51607     try {
51608       (arg1)->Emit();
51609     } catch (std::out_of_range& e) {
51610       {
51611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51612       };
51613     } catch (std::exception& e) {
51614       {
51615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51616       };
51617     } catch (Dali::DaliException e) {
51618       {
51619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51620       };
51621     } catch (...) {
51622       {
51623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51624       };
51625     }
51626   }
51627
51628 }
51629
51630
51631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
51632   unsigned int jresult ;
51633   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51634   bool result;
51635
51636   arg1 = (Dali::Signal< void (float) > *)jarg1;
51637   {
51638     try {
51639       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
51640     } catch (std::out_of_range& e) {
51641       {
51642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51643       };
51644     } catch (std::exception& e) {
51645       {
51646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51647       };
51648     } catch (Dali::DaliException e) {
51649       {
51650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51651       };
51652     } catch (...) {
51653       {
51654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51655       };
51656     }
51657   }
51658
51659   jresult = result;
51660   return jresult;
51661 }
51662
51663
51664 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
51665   unsigned long jresult ;
51666   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51667   std::size_t result;
51668
51669   arg1 = (Dali::Signal< void (float) > *)jarg1;
51670   {
51671     try {
51672       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
51673     } catch (std::out_of_range& e) {
51674       {
51675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51676       };
51677     } catch (std::exception& e) {
51678       {
51679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51680       };
51681     } catch (Dali::DaliException e) {
51682       {
51683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51684       };
51685     } catch (...) {
51686       {
51687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51688       };
51689     }
51690   }
51691
51692   jresult = (unsigned long)result;
51693   return jresult;
51694 }
51695
51696
51697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
51698   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51699   void (*arg2)(float) = (void (*)(float)) 0 ;
51700
51701   arg1 = (Dali::Signal< void (float) > *)jarg1;
51702   arg2 = (void (*)(float))jarg2;
51703   {
51704     try {
51705       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
51706     } catch (std::out_of_range& e) {
51707       {
51708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51709       };
51710     } catch (std::exception& e) {
51711       {
51712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51713       };
51714     } catch (Dali::DaliException e) {
51715       {
51716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51717       };
51718     } catch (...) {
51719       {
51720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51721       };
51722     }
51723   }
51724
51725 }
51726
51727
51728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
51729   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51730   void (*arg2)(float) = (void (*)(float)) 0 ;
51731
51732   arg1 = (Dali::Signal< void (float) > *)jarg1;
51733   arg2 = (void (*)(float))jarg2;
51734   {
51735     try {
51736       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
51737     } catch (std::out_of_range& e) {
51738       {
51739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51740       };
51741     } catch (std::exception& e) {
51742       {
51743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51744       };
51745     } catch (Dali::DaliException e) {
51746       {
51747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51748       };
51749     } catch (...) {
51750       {
51751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51752       };
51753     }
51754   }
51755
51756 }
51757
51758
51759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
51760   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51761   float arg2 ;
51762
51763   arg1 = (Dali::Signal< void (float) > *)jarg1;
51764   arg2 = (float)jarg2;
51765   {
51766     try {
51767       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
51768     } catch (std::out_of_range& e) {
51769       {
51770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51771       };
51772     } catch (std::exception& e) {
51773       {
51774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51775       };
51776     } catch (Dali::DaliException e) {
51777       {
51778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51779       };
51780     } catch (...) {
51781       {
51782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51783       };
51784     }
51785   }
51786
51787 }
51788
51789
51790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
51791   void * jresult ;
51792   Dali::Signal< void (float) > *result = 0 ;
51793
51794   {
51795     try {
51796       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
51797     } catch (std::out_of_range& e) {
51798       {
51799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51800       };
51801     } catch (std::exception& e) {
51802       {
51803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51804       };
51805     } catch (Dali::DaliException e) {
51806       {
51807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51808       };
51809     } catch (...) {
51810       {
51811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51812       };
51813     }
51814   }
51815
51816   jresult = (void *)result;
51817   return jresult;
51818 }
51819
51820
51821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
51822   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51823
51824   arg1 = (Dali::Signal< void (float) > *)jarg1;
51825   {
51826     try {
51827       delete arg1;
51828     } catch (std::out_of_range& e) {
51829       {
51830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51831       };
51832     } catch (std::exception& e) {
51833       {
51834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51835       };
51836     } catch (Dali::DaliException e) {
51837       {
51838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51839       };
51840     } catch (...) {
51841       {
51842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51843       };
51844     }
51845   }
51846
51847 }
51848
51849
51850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
51851   unsigned int jresult ;
51852   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51853   bool result;
51854
51855   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51856   {
51857     try {
51858       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
51859     } catch (std::out_of_range& e) {
51860       {
51861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51862       };
51863     } catch (std::exception& e) {
51864       {
51865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51866       };
51867     } catch (Dali::DaliException e) {
51868       {
51869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51870       };
51871     } catch (...) {
51872       {
51873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51874       };
51875     }
51876   }
51877
51878   jresult = result;
51879   return jresult;
51880 }
51881
51882
51883 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
51884   unsigned long jresult ;
51885   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51886   std::size_t result;
51887
51888   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51889   {
51890     try {
51891       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
51892     } catch (std::out_of_range& e) {
51893       {
51894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51895       };
51896     } catch (std::exception& e) {
51897       {
51898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51899       };
51900     } catch (Dali::DaliException e) {
51901       {
51902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51903       };
51904     } catch (...) {
51905       {
51906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51907       };
51908     }
51909   }
51910
51911   jresult = (unsigned long)result;
51912   return jresult;
51913 }
51914
51915
51916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
51917   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51918   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
51919
51920   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51921   arg2 = (void (*)(Dali::BaseHandle))jarg2;
51922   {
51923     try {
51924       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
51925     } catch (std::out_of_range& e) {
51926       {
51927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51928       };
51929     } catch (std::exception& e) {
51930       {
51931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51932       };
51933     } catch (Dali::DaliException e) {
51934       {
51935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51936       };
51937     } catch (...) {
51938       {
51939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51940       };
51941     }
51942   }
51943
51944 }
51945
51946
51947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
51948   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51949   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
51950
51951   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51952   arg2 = (void (*)(Dali::BaseHandle))jarg2;
51953   {
51954     try {
51955       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
51956     } catch (std::out_of_range& e) {
51957       {
51958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51959       };
51960     } catch (std::exception& e) {
51961       {
51962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51963       };
51964     } catch (Dali::DaliException e) {
51965       {
51966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51967       };
51968     } catch (...) {
51969       {
51970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51971       };
51972     }
51973   }
51974
51975 }
51976
51977
51978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
51979   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51980   Dali::BaseHandle arg2 ;
51981   Dali::BaseHandle *argp2 ;
51982
51983   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51984   argp2 = (Dali::BaseHandle *)jarg2;
51985   if (!argp2) {
51986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51987     return ;
51988   }
51989   arg2 = *argp2;
51990   {
51991     try {
51992       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
51993     } catch (std::out_of_range& e) {
51994       {
51995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51996       };
51997     } catch (std::exception& e) {
51998       {
51999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52000       };
52001     } catch (Dali::DaliException e) {
52002       {
52003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52004       };
52005     } catch (...) {
52006       {
52007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52008       };
52009     }
52010   }
52011
52012 }
52013
52014
52015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
52016   void * jresult ;
52017   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
52018
52019   {
52020     try {
52021       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
52022     } catch (std::out_of_range& e) {
52023       {
52024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52025       };
52026     } catch (std::exception& e) {
52027       {
52028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52029       };
52030     } catch (Dali::DaliException e) {
52031       {
52032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52033       };
52034     } catch (...) {
52035       {
52036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52037       };
52038     }
52039   }
52040
52041   jresult = (void *)result;
52042   return jresult;
52043 }
52044
52045
52046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
52047   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
52048
52049   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
52050   {
52051     try {
52052       delete arg1;
52053     } catch (std::out_of_range& e) {
52054       {
52055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52056       };
52057     } catch (std::exception& e) {
52058       {
52059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52060       };
52061     } catch (Dali::DaliException e) {
52062       {
52063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52064       };
52065     } catch (...) {
52066       {
52067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52068       };
52069     }
52070   }
52071
52072 }
52073
52074
52075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
52076   unsigned int jresult ;
52077   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
52078   bool result;
52079
52080   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
52081   {
52082     try {
52083       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
52084     } catch (std::out_of_range& e) {
52085       {
52086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52087       };
52088     } catch (std::exception& e) {
52089       {
52090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52091       };
52092     } catch (Dali::DaliException e) {
52093       {
52094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52095       };
52096     } catch (...) {
52097       {
52098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52099       };
52100     }
52101   }
52102
52103   jresult = result;
52104   return jresult;
52105 }
52106
52107
52108 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
52109   unsigned long jresult ;
52110   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
52111   std::size_t result;
52112
52113   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
52114   {
52115     try {
52116       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
52117     } catch (std::out_of_range& e) {
52118       {
52119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52120       };
52121     } catch (std::exception& e) {
52122       {
52123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52124       };
52125     } catch (Dali::DaliException e) {
52126       {
52127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52128       };
52129     } catch (...) {
52130       {
52131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52132       };
52133     }
52134   }
52135
52136   jresult = (unsigned long)result;
52137   return jresult;
52138 }
52139
52140
52141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
52142   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
52143   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
52144
52145   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
52146   arg2 = (void (*)(Dali::RefObject const *))jarg2;
52147   {
52148     try {
52149       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
52150     } catch (std::out_of_range& e) {
52151       {
52152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52153       };
52154     } catch (std::exception& e) {
52155       {
52156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52157       };
52158     } catch (Dali::DaliException e) {
52159       {
52160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52161       };
52162     } catch (...) {
52163       {
52164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52165       };
52166     }
52167   }
52168
52169 }
52170
52171
52172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
52173   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
52174   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
52175
52176   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
52177   arg2 = (void (*)(Dali::RefObject const *))jarg2;
52178   {
52179     try {
52180       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
52181     } catch (std::out_of_range& e) {
52182       {
52183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52184       };
52185     } catch (std::exception& e) {
52186       {
52187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52188       };
52189     } catch (Dali::DaliException e) {
52190       {
52191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52192       };
52193     } catch (...) {
52194       {
52195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52196       };
52197     }
52198   }
52199
52200 }
52201
52202
52203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
52204   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
52205   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
52206
52207   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
52208   arg2 = (Dali::RefObject *)jarg2;
52209   {
52210     try {
52211       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
52212     } catch (std::out_of_range& e) {
52213       {
52214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52215       };
52216     } catch (std::exception& e) {
52217       {
52218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52219       };
52220     } catch (Dali::DaliException e) {
52221       {
52222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52223       };
52224     } catch (...) {
52225       {
52226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52227       };
52228     }
52229   }
52230
52231 }
52232
52233
52234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
52235   void * jresult ;
52236   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
52237
52238   {
52239     try {
52240       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
52241     } catch (std::out_of_range& e) {
52242       {
52243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52244       };
52245     } catch (std::exception& e) {
52246       {
52247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52248       };
52249     } catch (Dali::DaliException e) {
52250       {
52251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52252       };
52253     } catch (...) {
52254       {
52255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52256       };
52257     }
52258   }
52259
52260   jresult = (void *)result;
52261   return jresult;
52262 }
52263
52264
52265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
52266   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
52267
52268   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
52269   {
52270     try {
52271       delete arg1;
52272     } catch (std::out_of_range& e) {
52273       {
52274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52275       };
52276     } catch (std::exception& e) {
52277       {
52278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52279       };
52280     } catch (Dali::DaliException e) {
52281       {
52282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52283       };
52284     } catch (...) {
52285       {
52286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52287       };
52288     }
52289   }
52290
52291 }
52292
52293
52294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
52295   unsigned int jresult ;
52296   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
52297   bool result;
52298
52299   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
52300   {
52301     try {
52302       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
52303     } catch (std::out_of_range& e) {
52304       {
52305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52306       };
52307     } catch (std::exception& e) {
52308       {
52309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52310       };
52311     } catch (Dali::DaliException e) {
52312       {
52313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52314       };
52315     } catch (...) {
52316       {
52317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52318       };
52319     }
52320   }
52321
52322   jresult = result;
52323   return jresult;
52324 }
52325
52326
52327 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
52328   unsigned long jresult ;
52329   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
52330   std::size_t result;
52331
52332   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
52333   {
52334     try {
52335       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
52336     } catch (std::out_of_range& e) {
52337       {
52338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52339       };
52340     } catch (std::exception& e) {
52341       {
52342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52343       };
52344     } catch (Dali::DaliException e) {
52345       {
52346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52347       };
52348     } catch (...) {
52349       {
52350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52351       };
52352     }
52353   }
52354
52355   jresult = (unsigned long)result;
52356   return jresult;
52357 }
52358
52359
52360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
52361   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
52362   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
52363
52364   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
52365   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
52366   {
52367     try {
52368       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
52369     } catch (std::out_of_range& e) {
52370       {
52371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52372       };
52373     } catch (std::exception& e) {
52374       {
52375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52376       };
52377     } catch (Dali::DaliException e) {
52378       {
52379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52380       };
52381     } catch (...) {
52382       {
52383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52384       };
52385     }
52386   }
52387
52388 }
52389
52390
52391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
52392   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
52393   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
52394
52395   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
52396   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
52397   {
52398     try {
52399       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
52400     } catch (std::out_of_range& e) {
52401       {
52402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52403       };
52404     } catch (std::exception& e) {
52405       {
52406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52407       };
52408     } catch (Dali::DaliException e) {
52409       {
52410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52411       };
52412     } catch (...) {
52413       {
52414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52415       };
52416     }
52417   }
52418
52419 }
52420
52421
52422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
52423   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
52424   Dali::PropertyNotification *arg2 = 0 ;
52425
52426   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
52427   arg2 = (Dali::PropertyNotification *)jarg2;
52428   if (!arg2) {
52429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
52430     return ;
52431   }
52432   {
52433     try {
52434       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
52435     } catch (std::out_of_range& e) {
52436       {
52437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52438       };
52439     } catch (std::exception& e) {
52440       {
52441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52442       };
52443     } catch (Dali::DaliException e) {
52444       {
52445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52446       };
52447     } catch (...) {
52448       {
52449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52450       };
52451     }
52452   }
52453
52454 }
52455
52456
52457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
52458   void * jresult ;
52459   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
52460
52461   {
52462     try {
52463       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
52464     } catch (std::out_of_range& e) {
52465       {
52466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52467       };
52468     } catch (std::exception& e) {
52469       {
52470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52471       };
52472     } catch (Dali::DaliException e) {
52473       {
52474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52475       };
52476     } catch (...) {
52477       {
52478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52479       };
52480     }
52481   }
52482
52483   jresult = (void *)result;
52484   return jresult;
52485 }
52486
52487
52488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
52489   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
52490
52491   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
52492   {
52493     try {
52494       delete arg1;
52495     } catch (std::out_of_range& e) {
52496       {
52497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52498       };
52499     } catch (std::exception& e) {
52500       {
52501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52502       };
52503     } catch (Dali::DaliException e) {
52504       {
52505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52506       };
52507     } catch (...) {
52508       {
52509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52510       };
52511     }
52512   }
52513
52514 }
52515
52516
52517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
52518   void * jresult ;
52519   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
52520
52521   {
52522     try {
52523       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
52524     } catch (std::out_of_range& e) {
52525       {
52526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52527       };
52528     } catch (std::exception& e) {
52529       {
52530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52531       };
52532     } catch (Dali::DaliException e) {
52533       {
52534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52535       };
52536     } catch (...) {
52537       {
52538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52539       };
52540     }
52541   }
52542
52543   jresult = (void *)result;
52544   return jresult;
52545 }
52546
52547
52548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
52549   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
52550
52551   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
52552   {
52553     try {
52554       delete arg1;
52555     } catch (std::out_of_range& e) {
52556       {
52557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52558       };
52559     } catch (std::exception& e) {
52560       {
52561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52562       };
52563     } catch (Dali::DaliException e) {
52564       {
52565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52566       };
52567     } catch (...) {
52568       {
52569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52570       };
52571     }
52572   }
52573
52574 }
52575
52576
52577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
52578   unsigned int jresult ;
52579   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
52580   bool result;
52581
52582   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
52583   {
52584     try {
52585       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);
52586     } catch (std::out_of_range& e) {
52587       {
52588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52589       };
52590     } catch (std::exception& e) {
52591       {
52592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52593       };
52594     } catch (Dali::DaliException e) {
52595       {
52596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52597       };
52598     } catch (...) {
52599       {
52600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52601       };
52602     }
52603   }
52604
52605   jresult = result;
52606   return jresult;
52607 }
52608
52609
52610 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52611   unsigned long jresult ;
52612   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
52613   std::size_t result;
52614
52615   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
52616   {
52617     try {
52618       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);
52619     } catch (std::out_of_range& e) {
52620       {
52621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52622       };
52623     } catch (std::exception& e) {
52624       {
52625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52626       };
52627     } catch (Dali::DaliException e) {
52628       {
52629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52630       };
52631     } catch (...) {
52632       {
52633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52634       };
52635     }
52636   }
52637
52638   jresult = (unsigned long)result;
52639   return jresult;
52640 }
52641
52642
52643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
52644   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
52645   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
52646
52647   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
52648   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
52649   {
52650     try {
52651       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52652     } catch (std::out_of_range& e) {
52653       {
52654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52655       };
52656     } catch (std::exception& e) {
52657       {
52658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52659       };
52660     } catch (Dali::DaliException e) {
52661       {
52662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52663       };
52664     } catch (...) {
52665       {
52666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52667       };
52668     }
52669   }
52670
52671 }
52672
52673
52674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52675   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
52676   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
52677
52678   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
52679   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
52680   {
52681     try {
52682       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52683     } catch (std::out_of_range& e) {
52684       {
52685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52686       };
52687     } catch (std::exception& e) {
52688       {
52689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52690       };
52691     } catch (Dali::DaliException e) {
52692       {
52693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52694       };
52695     } catch (...) {
52696       {
52697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52698       };
52699     }
52700   }
52701
52702 }
52703
52704
52705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52706   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
52707   Dali::Actor arg2 ;
52708   Dali::LongPressGesture *arg3 = 0 ;
52709   Dali::Actor *argp2 ;
52710
52711   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
52712   argp2 = (Dali::Actor *)jarg2;
52713   if (!argp2) {
52714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52715     return ;
52716   }
52717   arg2 = *argp2;
52718   arg3 = (Dali::LongPressGesture *)jarg3;
52719   if (!arg3) {
52720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
52721     return ;
52722   }
52723   {
52724     try {
52725       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
52726     } catch (std::out_of_range& e) {
52727       {
52728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52729       };
52730     } catch (std::exception& e) {
52731       {
52732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52733       };
52734     } catch (Dali::DaliException e) {
52735       {
52736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52737       };
52738     } catch (...) {
52739       {
52740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52741       };
52742     }
52743   }
52744
52745 }
52746
52747
52748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
52749   void * jresult ;
52750   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
52751
52752   {
52753     try {
52754       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
52755     } catch (std::out_of_range& e) {
52756       {
52757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52758       };
52759     } catch (std::exception& e) {
52760       {
52761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52762       };
52763     } catch (Dali::DaliException e) {
52764       {
52765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52766       };
52767     } catch (...) {
52768       {
52769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52770       };
52771     }
52772   }
52773
52774   jresult = (void *)result;
52775   return jresult;
52776 }
52777
52778
52779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
52780   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
52781
52782   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
52783   {
52784     try {
52785       delete arg1;
52786     } catch (std::out_of_range& e) {
52787       {
52788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52789       };
52790     } catch (std::exception& e) {
52791       {
52792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52793       };
52794     } catch (Dali::DaliException e) {
52795       {
52796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52797       };
52798     } catch (...) {
52799       {
52800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52801       };
52802     }
52803   }
52804
52805 }
52806
52807
52808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
52809   unsigned int jresult ;
52810   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52811   bool result;
52812
52813   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52814   {
52815     try {
52816       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);
52817     } catch (std::out_of_range& e) {
52818       {
52819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52820       };
52821     } catch (std::exception& e) {
52822       {
52823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52824       };
52825     } catch (Dali::DaliException e) {
52826       {
52827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52828       };
52829     } catch (...) {
52830       {
52831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52832       };
52833     }
52834   }
52835
52836   jresult = result;
52837   return jresult;
52838 }
52839
52840
52841 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
52842   unsigned long jresult ;
52843   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52844   std::size_t result;
52845
52846   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52847   {
52848     try {
52849       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);
52850     } catch (std::out_of_range& e) {
52851       {
52852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52853       };
52854     } catch (std::exception& e) {
52855       {
52856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52857       };
52858     } catch (Dali::DaliException e) {
52859       {
52860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52861       };
52862     } catch (...) {
52863       {
52864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52865       };
52866     }
52867   }
52868
52869   jresult = (unsigned long)result;
52870   return jresult;
52871 }
52872
52873
52874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
52875   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52876   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
52877
52878   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52879   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
52880   {
52881     try {
52882       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52883     } catch (std::out_of_range& e) {
52884       {
52885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52886       };
52887     } catch (std::exception& e) {
52888       {
52889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52890       };
52891     } catch (Dali::DaliException e) {
52892       {
52893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52894       };
52895     } catch (...) {
52896       {
52897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52898       };
52899     }
52900   }
52901
52902 }
52903
52904
52905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
52906   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52907   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
52908
52909   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52910   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
52911   {
52912     try {
52913       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52914     } catch (std::out_of_range& e) {
52915       {
52916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52917       };
52918     } catch (std::exception& e) {
52919       {
52920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52921       };
52922     } catch (Dali::DaliException e) {
52923       {
52924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52925       };
52926     } catch (...) {
52927       {
52928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52929       };
52930     }
52931   }
52932
52933 }
52934
52935
52936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52937   unsigned int jresult ;
52938   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52939   Dali::Actor arg2 ;
52940   Dali::TouchData *arg3 = 0 ;
52941   Dali::Actor *argp2 ;
52942   bool result;
52943
52944   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52945   argp2 = (Dali::Actor *)jarg2;
52946   if (!argp2) {
52947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52948     return 0;
52949   }
52950   arg2 = *argp2;
52951   arg3 = (Dali::TouchData *)jarg3;
52952   if (!arg3) {
52953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
52954     return 0;
52955   }
52956   {
52957     try {
52958       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
52959     } catch (std::out_of_range& e) {
52960       {
52961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52962       };
52963     } catch (std::exception& e) {
52964       {
52965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52966       };
52967     } catch (Dali::DaliException e) {
52968       {
52969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52970       };
52971     } catch (...) {
52972       {
52973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52974       };
52975     }
52976   }
52977
52978   jresult = result;
52979   return jresult;
52980 }
52981
52982
52983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
52984   void * jresult ;
52985   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
52986
52987   {
52988     try {
52989       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
52990     } catch (std::out_of_range& e) {
52991       {
52992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52993       };
52994     } catch (std::exception& e) {
52995       {
52996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52997       };
52998     } catch (Dali::DaliException e) {
52999       {
53000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53001       };
53002     } catch (...) {
53003       {
53004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53005       };
53006     }
53007   }
53008
53009   jresult = (void *)result;
53010   return jresult;
53011 }
53012
53013
53014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
53015   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
53016
53017   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
53018   {
53019     try {
53020       delete arg1;
53021     } catch (std::out_of_range& e) {
53022       {
53023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53024       };
53025     } catch (std::exception& e) {
53026       {
53027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53028       };
53029     } catch (Dali::DaliException e) {
53030       {
53031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53032       };
53033     } catch (...) {
53034       {
53035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53036       };
53037     }
53038   }
53039
53040 }
53041
53042
53043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
53044   unsigned int jresult ;
53045   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
53046   bool result;
53047
53048   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
53049   {
53050     try {
53051       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);
53052     } catch (std::out_of_range& e) {
53053       {
53054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53055       };
53056     } catch (std::exception& e) {
53057       {
53058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53059       };
53060     } catch (Dali::DaliException e) {
53061       {
53062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53063       };
53064     } catch (...) {
53065       {
53066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53067       };
53068     }
53069   }
53070
53071   jresult = result;
53072   return jresult;
53073 }
53074
53075
53076 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
53077   unsigned long jresult ;
53078   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
53079   std::size_t result;
53080
53081   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
53082   {
53083     try {
53084       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);
53085     } catch (std::out_of_range& e) {
53086       {
53087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53088       };
53089     } catch (std::exception& e) {
53090       {
53091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53092       };
53093     } catch (Dali::DaliException e) {
53094       {
53095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53096       };
53097     } catch (...) {
53098       {
53099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53100       };
53101     }
53102   }
53103
53104   jresult = (unsigned long)result;
53105   return jresult;
53106 }
53107
53108
53109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
53110   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
53111   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
53112
53113   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
53114   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
53115   {
53116     try {
53117       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53118     } catch (std::out_of_range& e) {
53119       {
53120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53121       };
53122     } catch (std::exception& e) {
53123       {
53124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53125       };
53126     } catch (Dali::DaliException e) {
53127       {
53128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53129       };
53130     } catch (...) {
53131       {
53132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53133       };
53134     }
53135   }
53136
53137 }
53138
53139
53140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
53141   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
53142   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
53143
53144   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
53145   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
53146   {
53147     try {
53148       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53149     } catch (std::out_of_range& e) {
53150       {
53151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53152       };
53153     } catch (std::exception& e) {
53154       {
53155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53156       };
53157     } catch (Dali::DaliException e) {
53158       {
53159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53160       };
53161     } catch (...) {
53162       {
53163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53164       };
53165     }
53166   }
53167
53168 }
53169
53170
53171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53172   unsigned int jresult ;
53173   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
53174   Dali::Actor arg2 ;
53175   Dali::HoverEvent *arg3 = 0 ;
53176   Dali::Actor *argp2 ;
53177   bool result;
53178
53179   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
53180   argp2 = (Dali::Actor *)jarg2;
53181   if (!argp2) {
53182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53183     return 0;
53184   }
53185   arg2 = *argp2;
53186   arg3 = (Dali::HoverEvent *)jarg3;
53187   if (!arg3) {
53188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
53189     return 0;
53190   }
53191   {
53192     try {
53193       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
53194     } catch (std::out_of_range& e) {
53195       {
53196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53197       };
53198     } catch (std::exception& e) {
53199       {
53200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53201       };
53202     } catch (Dali::DaliException e) {
53203       {
53204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53205       };
53206     } catch (...) {
53207       {
53208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53209       };
53210     }
53211   }
53212
53213   jresult = result;
53214   return jresult;
53215 }
53216
53217
53218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
53219   void * jresult ;
53220   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
53221
53222   {
53223     try {
53224       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
53225     } catch (std::out_of_range& e) {
53226       {
53227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53228       };
53229     } catch (std::exception& e) {
53230       {
53231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53232       };
53233     } catch (Dali::DaliException e) {
53234       {
53235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53236       };
53237     } catch (...) {
53238       {
53239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53240       };
53241     }
53242   }
53243
53244   jresult = (void *)result;
53245   return jresult;
53246 }
53247
53248
53249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
53250   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
53251
53252   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
53253   {
53254     try {
53255       delete arg1;
53256     } catch (std::out_of_range& e) {
53257       {
53258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53259       };
53260     } catch (std::exception& e) {
53261       {
53262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53263       };
53264     } catch (Dali::DaliException e) {
53265       {
53266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53267       };
53268     } catch (...) {
53269       {
53270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53271       };
53272     }
53273   }
53274
53275 }
53276
53277
53278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
53279   unsigned int jresult ;
53280   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
53281   bool result;
53282
53283   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
53284   {
53285     try {
53286       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);
53287     } catch (std::out_of_range& e) {
53288       {
53289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53290       };
53291     } catch (std::exception& e) {
53292       {
53293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53294       };
53295     } catch (Dali::DaliException e) {
53296       {
53297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53298       };
53299     } catch (...) {
53300       {
53301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53302       };
53303     }
53304   }
53305
53306   jresult = result;
53307   return jresult;
53308 }
53309
53310
53311 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
53312   unsigned long jresult ;
53313   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
53314   std::size_t result;
53315
53316   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
53317   {
53318     try {
53319       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);
53320     } catch (std::out_of_range& e) {
53321       {
53322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53323       };
53324     } catch (std::exception& e) {
53325       {
53326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53327       };
53328     } catch (Dali::DaliException e) {
53329       {
53330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53331       };
53332     } catch (...) {
53333       {
53334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53335       };
53336     }
53337   }
53338
53339   jresult = (unsigned long)result;
53340   return jresult;
53341 }
53342
53343
53344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
53345   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
53346   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
53347
53348   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
53349   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
53350   {
53351     try {
53352       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53353     } catch (std::out_of_range& e) {
53354       {
53355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53356       };
53357     } catch (std::exception& e) {
53358       {
53359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53360       };
53361     } catch (Dali::DaliException e) {
53362       {
53363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53364       };
53365     } catch (...) {
53366       {
53367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53368       };
53369     }
53370   }
53371
53372 }
53373
53374
53375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
53376   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
53377   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
53378
53379   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
53380   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
53381   {
53382     try {
53383       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53384     } catch (std::out_of_range& e) {
53385       {
53386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53387       };
53388     } catch (std::exception& e) {
53389       {
53390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53391       };
53392     } catch (Dali::DaliException e) {
53393       {
53394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53395       };
53396     } catch (...) {
53397       {
53398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53399       };
53400     }
53401   }
53402
53403 }
53404
53405
53406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53407   unsigned int jresult ;
53408   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
53409   Dali::Actor arg2 ;
53410   Dali::WheelEvent *arg3 = 0 ;
53411   Dali::Actor *argp2 ;
53412   bool result;
53413
53414   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
53415   argp2 = (Dali::Actor *)jarg2;
53416   if (!argp2) {
53417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53418     return 0;
53419   }
53420   arg2 = *argp2;
53421   arg3 = (Dali::WheelEvent *)jarg3;
53422   if (!arg3) {
53423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
53424     return 0;
53425   }
53426   {
53427     try {
53428       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
53429     } catch (std::out_of_range& e) {
53430       {
53431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53432       };
53433     } catch (std::exception& e) {
53434       {
53435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53436       };
53437     } catch (Dali::DaliException e) {
53438       {
53439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53440       };
53441     } catch (...) {
53442       {
53443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53444       };
53445     }
53446   }
53447
53448   jresult = result;
53449   return jresult;
53450 }
53451
53452
53453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
53454   void * jresult ;
53455   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
53456
53457   {
53458     try {
53459       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
53460     } catch (std::out_of_range& e) {
53461       {
53462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53463       };
53464     } catch (std::exception& e) {
53465       {
53466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53467       };
53468     } catch (Dali::DaliException e) {
53469       {
53470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53471       };
53472     } catch (...) {
53473       {
53474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53475       };
53476     }
53477   }
53478
53479   jresult = (void *)result;
53480   return jresult;
53481 }
53482
53483
53484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
53485   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
53486
53487   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
53488   {
53489     try {
53490       delete arg1;
53491     } catch (std::out_of_range& e) {
53492       {
53493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53494       };
53495     } catch (std::exception& e) {
53496       {
53497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53498       };
53499     } catch (Dali::DaliException e) {
53500       {
53501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53502       };
53503     } catch (...) {
53504       {
53505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53506       };
53507     }
53508   }
53509
53510 }
53511
53512
53513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
53514   unsigned int jresult ;
53515   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
53516   bool result;
53517
53518   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
53519   {
53520     try {
53521       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
53522     } catch (std::out_of_range& e) {
53523       {
53524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53525       };
53526     } catch (std::exception& e) {
53527       {
53528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53529       };
53530     } catch (Dali::DaliException e) {
53531       {
53532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53533       };
53534     } catch (...) {
53535       {
53536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53537       };
53538     }
53539   }
53540
53541   jresult = result;
53542   return jresult;
53543 }
53544
53545
53546 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
53547   unsigned long jresult ;
53548   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
53549   std::size_t result;
53550
53551   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
53552   {
53553     try {
53554       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
53555     } catch (std::out_of_range& e) {
53556       {
53557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53558       };
53559     } catch (std::exception& e) {
53560       {
53561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53562       };
53563     } catch (Dali::DaliException e) {
53564       {
53565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53566       };
53567     } catch (...) {
53568       {
53569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53570       };
53571     }
53572   }
53573
53574   jresult = (unsigned long)result;
53575   return jresult;
53576 }
53577
53578
53579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
53580   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
53581   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
53582
53583   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
53584   arg2 = (void (*)(Dali::Actor))jarg2;
53585   {
53586     try {
53587       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
53588     } catch (std::out_of_range& e) {
53589       {
53590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53591       };
53592     } catch (std::exception& e) {
53593       {
53594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53595       };
53596     } catch (Dali::DaliException e) {
53597       {
53598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53599       };
53600     } catch (...) {
53601       {
53602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53603       };
53604     }
53605   }
53606
53607 }
53608
53609
53610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
53611   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
53612   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
53613
53614   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
53615   arg2 = (void (*)(Dali::Actor))jarg2;
53616   {
53617     try {
53618       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
53619     } catch (std::out_of_range& e) {
53620       {
53621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53622       };
53623     } catch (std::exception& e) {
53624       {
53625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53626       };
53627     } catch (Dali::DaliException e) {
53628       {
53629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53630       };
53631     } catch (...) {
53632       {
53633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53634       };
53635     }
53636   }
53637
53638 }
53639
53640
53641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
53642   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
53643   Dali::Actor arg2 ;
53644   Dali::Actor *argp2 ;
53645
53646   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
53647   argp2 = (Dali::Actor *)jarg2;
53648   if (!argp2) {
53649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53650     return ;
53651   }
53652   arg2 = *argp2;
53653   {
53654     try {
53655       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
53656     } catch (std::out_of_range& e) {
53657       {
53658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53659       };
53660     } catch (std::exception& e) {
53661       {
53662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53663       };
53664     } catch (Dali::DaliException e) {
53665       {
53666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53667       };
53668     } catch (...) {
53669       {
53670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53671       };
53672     }
53673   }
53674
53675 }
53676
53677
53678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
53679   void * jresult ;
53680   Dali::Signal< void (Dali::Actor) > *result = 0 ;
53681
53682   {
53683     try {
53684       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
53685     } catch (std::out_of_range& e) {
53686       {
53687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53688       };
53689     } catch (std::exception& e) {
53690       {
53691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53692       };
53693     } catch (Dali::DaliException e) {
53694       {
53695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53696       };
53697     } catch (...) {
53698       {
53699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53700       };
53701     }
53702   }
53703
53704   jresult = (void *)result;
53705   return jresult;
53706 }
53707
53708
53709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
53710   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
53711
53712   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
53713   {
53714     try {
53715       delete arg1;
53716     } catch (std::out_of_range& e) {
53717       {
53718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53719       };
53720     } catch (std::exception& e) {
53721       {
53722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53723       };
53724     } catch (Dali::DaliException e) {
53725       {
53726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53727       };
53728     } catch (...) {
53729       {
53730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53731       };
53732     }
53733   }
53734
53735 }
53736
53737
53738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
53739   unsigned int jresult ;
53740   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53741   bool result;
53742
53743   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53744   {
53745     try {
53746       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
53747     } catch (std::out_of_range& e) {
53748       {
53749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53750       };
53751     } catch (std::exception& e) {
53752       {
53753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53754       };
53755     } catch (Dali::DaliException e) {
53756       {
53757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53758       };
53759     } catch (...) {
53760       {
53761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53762       };
53763     }
53764   }
53765
53766   jresult = result;
53767   return jresult;
53768 }
53769
53770
53771 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
53772   unsigned long jresult ;
53773   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53774   std::size_t result;
53775
53776   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53777   {
53778     try {
53779       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
53780     } catch (std::out_of_range& e) {
53781       {
53782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53783       };
53784     } catch (std::exception& e) {
53785       {
53786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53787       };
53788     } catch (Dali::DaliException e) {
53789       {
53790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53791       };
53792     } catch (...) {
53793       {
53794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53795       };
53796     }
53797   }
53798
53799   jresult = (unsigned long)result;
53800   return jresult;
53801 }
53802
53803
53804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
53805   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53806   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
53807
53808   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53809   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
53810   {
53811     try {
53812       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53813     } catch (std::out_of_range& e) {
53814       {
53815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53816       };
53817     } catch (std::exception& e) {
53818       {
53819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53820       };
53821     } catch (Dali::DaliException e) {
53822       {
53823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53824       };
53825     } catch (...) {
53826       {
53827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53828       };
53829     }
53830   }
53831
53832 }
53833
53834
53835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
53836   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53837   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
53838
53839   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53840   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
53841   {
53842     try {
53843       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53844     } catch (std::out_of_range& e) {
53845       {
53846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53847       };
53848     } catch (std::exception& e) {
53849       {
53850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53851       };
53852     } catch (Dali::DaliException e) {
53853       {
53854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53855       };
53856     } catch (...) {
53857       {
53858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53859       };
53860     }
53861   }
53862
53863 }
53864
53865
53866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
53867   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53868   Dali::KeyEvent *arg2 = 0 ;
53869
53870   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53871   arg2 = (Dali::KeyEvent *)jarg2;
53872   if (!arg2) {
53873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
53874     return ;
53875   }
53876   {
53877     try {
53878       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
53879     } catch (std::out_of_range& e) {
53880       {
53881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53882       };
53883     } catch (std::exception& e) {
53884       {
53885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53886       };
53887     } catch (Dali::DaliException e) {
53888       {
53889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53890       };
53891     } catch (...) {
53892       {
53893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53894       };
53895     }
53896   }
53897
53898 }
53899
53900
53901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
53902   void * jresult ;
53903   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
53904
53905   {
53906     try {
53907       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
53908     } catch (std::out_of_range& e) {
53909       {
53910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53911       };
53912     } catch (std::exception& e) {
53913       {
53914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53915       };
53916     } catch (Dali::DaliException e) {
53917       {
53918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53919       };
53920     } catch (...) {
53921       {
53922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53923       };
53924     }
53925   }
53926
53927   jresult = (void *)result;
53928   return jresult;
53929 }
53930
53931
53932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
53933   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53934
53935   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53936   {
53937     try {
53938       delete arg1;
53939     } catch (std::out_of_range& e) {
53940       {
53941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53942       };
53943     } catch (std::exception& e) {
53944       {
53945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53946       };
53947     } catch (Dali::DaliException e) {
53948       {
53949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53950       };
53951     } catch (...) {
53952       {
53953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53954       };
53955     }
53956   }
53957
53958 }
53959
53960
53961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
53962   unsigned int jresult ;
53963   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53964   bool result;
53965
53966   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53967   {
53968     try {
53969       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
53970     } catch (std::out_of_range& e) {
53971       {
53972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53973       };
53974     } catch (std::exception& e) {
53975       {
53976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53977       };
53978     } catch (Dali::DaliException e) {
53979       {
53980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53981       };
53982     } catch (...) {
53983       {
53984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53985       };
53986     }
53987   }
53988
53989   jresult = result;
53990   return jresult;
53991 }
53992
53993
53994 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
53995   unsigned long jresult ;
53996   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53997   std::size_t result;
53998
53999   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
54000   {
54001     try {
54002       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
54003     } catch (std::out_of_range& e) {
54004       {
54005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54006       };
54007     } catch (std::exception& e) {
54008       {
54009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54010       };
54011     } catch (Dali::DaliException e) {
54012       {
54013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54014       };
54015     } catch (...) {
54016       {
54017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54018       };
54019     }
54020   }
54021
54022   jresult = (unsigned long)result;
54023   return jresult;
54024 }
54025
54026
54027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
54028   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
54029   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
54030
54031   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
54032   arg2 = (void (*)(Dali::TouchData const &))jarg2;
54033   {
54034     try {
54035       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54036     } catch (std::out_of_range& e) {
54037       {
54038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54039       };
54040     } catch (std::exception& e) {
54041       {
54042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54043       };
54044     } catch (Dali::DaliException e) {
54045       {
54046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54047       };
54048     } catch (...) {
54049       {
54050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54051       };
54052     }
54053   }
54054
54055 }
54056
54057
54058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
54059   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
54060   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
54061
54062   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
54063   arg2 = (void (*)(Dali::TouchData const &))jarg2;
54064   {
54065     try {
54066       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54067     } catch (std::out_of_range& e) {
54068       {
54069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54070       };
54071     } catch (std::exception& e) {
54072       {
54073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54074       };
54075     } catch (Dali::DaliException e) {
54076       {
54077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54078       };
54079     } catch (...) {
54080       {
54081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54082       };
54083     }
54084   }
54085
54086 }
54087
54088
54089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
54090   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
54091   Dali::TouchData *arg2 = 0 ;
54092
54093   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
54094   arg2 = (Dali::TouchData *)jarg2;
54095   if (!arg2) {
54096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
54097     return ;
54098   }
54099   {
54100     try {
54101       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
54102     } catch (std::out_of_range& e) {
54103       {
54104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54105       };
54106     } catch (std::exception& e) {
54107       {
54108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54109       };
54110     } catch (Dali::DaliException e) {
54111       {
54112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54113       };
54114     } catch (...) {
54115       {
54116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54117       };
54118     }
54119   }
54120
54121 }
54122
54123
54124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
54125   void * jresult ;
54126   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
54127
54128   {
54129     try {
54130       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
54131     } catch (std::out_of_range& e) {
54132       {
54133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54134       };
54135     } catch (std::exception& e) {
54136       {
54137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54138       };
54139     } catch (Dali::DaliException e) {
54140       {
54141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54142       };
54143     } catch (...) {
54144       {
54145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54146       };
54147     }
54148   }
54149
54150   jresult = (void *)result;
54151   return jresult;
54152 }
54153
54154
54155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
54156   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
54157
54158   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
54159   {
54160     try {
54161       delete arg1;
54162     } catch (std::out_of_range& e) {
54163       {
54164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54165       };
54166     } catch (std::exception& e) {
54167       {
54168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54169       };
54170     } catch (Dali::DaliException e) {
54171       {
54172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54173       };
54174     } catch (...) {
54175       {
54176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54177       };
54178     }
54179   }
54180
54181 }
54182
54183
54184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
54185   unsigned int jresult ;
54186   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
54187   bool result;
54188
54189   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
54190   {
54191     try {
54192       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
54193     } catch (std::out_of_range& e) {
54194       {
54195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54196       };
54197     } catch (std::exception& e) {
54198       {
54199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54200       };
54201     } catch (Dali::DaliException e) {
54202       {
54203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54204       };
54205     } catch (...) {
54206       {
54207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54208       };
54209     }
54210   }
54211
54212   jresult = result;
54213   return jresult;
54214 }
54215
54216
54217 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
54218   unsigned long jresult ;
54219   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
54220   std::size_t result;
54221
54222   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
54223   {
54224     try {
54225       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
54226     } catch (std::out_of_range& e) {
54227       {
54228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54229       };
54230     } catch (std::exception& e) {
54231       {
54232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54233       };
54234     } catch (Dali::DaliException e) {
54235       {
54236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54237       };
54238     } catch (...) {
54239       {
54240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54241       };
54242     }
54243   }
54244
54245   jresult = (unsigned long)result;
54246   return jresult;
54247 }
54248
54249
54250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
54251   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
54252   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
54253
54254   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
54255   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
54256   {
54257     try {
54258       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54259     } catch (std::out_of_range& e) {
54260       {
54261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54262       };
54263     } catch (std::exception& e) {
54264       {
54265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54266       };
54267     } catch (Dali::DaliException e) {
54268       {
54269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54270       };
54271     } catch (...) {
54272       {
54273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54274       };
54275     }
54276   }
54277
54278 }
54279
54280
54281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
54282   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
54283   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
54284
54285   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
54286   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
54287   {
54288     try {
54289       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54290     } catch (std::out_of_range& e) {
54291       {
54292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54293       };
54294     } catch (std::exception& e) {
54295       {
54296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54297       };
54298     } catch (Dali::DaliException e) {
54299       {
54300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54301       };
54302     } catch (...) {
54303       {
54304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54305       };
54306     }
54307   }
54308
54309 }
54310
54311
54312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
54313   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
54314   Dali::WheelEvent *arg2 = 0 ;
54315
54316   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
54317   arg2 = (Dali::WheelEvent *)jarg2;
54318   if (!arg2) {
54319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
54320     return ;
54321   }
54322   {
54323     try {
54324       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
54325     } catch (std::out_of_range& e) {
54326       {
54327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54328       };
54329     } catch (std::exception& e) {
54330       {
54331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54332       };
54333     } catch (Dali::DaliException e) {
54334       {
54335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54336       };
54337     } catch (...) {
54338       {
54339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54340       };
54341     }
54342   }
54343
54344 }
54345
54346
54347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
54348   void * jresult ;
54349   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
54350
54351   {
54352     try {
54353       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
54354     } catch (std::out_of_range& e) {
54355       {
54356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54357       };
54358     } catch (std::exception& e) {
54359       {
54360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54361       };
54362     } catch (Dali::DaliException e) {
54363       {
54364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54365       };
54366     } catch (...) {
54367       {
54368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54369       };
54370     }
54371   }
54372
54373   jresult = (void *)result;
54374   return jresult;
54375 }
54376
54377
54378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
54379   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
54380
54381   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
54382   {
54383     try {
54384       delete arg1;
54385     } catch (std::out_of_range& e) {
54386       {
54387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54388       };
54389     } catch (std::exception& e) {
54390       {
54391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54392       };
54393     } catch (Dali::DaliException e) {
54394       {
54395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54396       };
54397     } catch (...) {
54398       {
54399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54400       };
54401     }
54402   }
54403
54404 }
54405
54406
54407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
54408   void * jresult ;
54409   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
54410
54411   {
54412     try {
54413       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
54414     } catch (std::out_of_range& e) {
54415       {
54416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54417       };
54418     } catch (std::exception& e) {
54419       {
54420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54421       };
54422     } catch (Dali::DaliException e) {
54423       {
54424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54425       };
54426     } catch (...) {
54427       {
54428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54429       };
54430     }
54431   }
54432
54433   jresult = (void *)result;
54434   return jresult;
54435 }
54436
54437
54438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
54439   void * jresult ;
54440   Dali::Radian arg1 ;
54441   Dali::Radian arg2 ;
54442   Dali::Radian *argp1 ;
54443   Dali::Radian *argp2 ;
54444   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
54445
54446   argp1 = (Dali::Radian *)jarg1;
54447   if (!argp1) {
54448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
54449     return 0;
54450   }
54451   arg1 = *argp1;
54452   argp2 = (Dali::Radian *)jarg2;
54453   if (!argp2) {
54454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
54455     return 0;
54456   }
54457   arg2 = *argp2;
54458   {
54459     try {
54460       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
54461     } catch (std::out_of_range& e) {
54462       {
54463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54464       };
54465     } catch (std::exception& e) {
54466       {
54467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54468       };
54469     } catch (Dali::DaliException e) {
54470       {
54471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54472       };
54473     } catch (...) {
54474       {
54475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54476       };
54477     }
54478   }
54479
54480   jresult = (void *)result;
54481   return jresult;
54482 }
54483
54484
54485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
54486   void * jresult ;
54487   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
54488   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
54489
54490   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
54491   if (!arg1) {
54492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
54493     return 0;
54494   }
54495   {
54496     try {
54497       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
54498     } catch (std::out_of_range& e) {
54499       {
54500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54501       };
54502     } catch (std::exception& e) {
54503       {
54504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54505       };
54506     } catch (Dali::DaliException e) {
54507       {
54508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54509       };
54510     } catch (...) {
54511       {
54512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54513       };
54514     }
54515   }
54516
54517   jresult = (void *)result;
54518   return jresult;
54519 }
54520
54521
54522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
54523   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
54524   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
54525
54526   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
54527   arg2 = (Dali::Radian *)jarg2;
54528   if (arg1) (arg1)->first = *arg2;
54529 }
54530
54531
54532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
54533   void * jresult ;
54534   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
54535   Dali::Radian *result = 0 ;
54536
54537   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
54538   result = (Dali::Radian *)& ((arg1)->first);
54539   jresult = (void *)result;
54540   return jresult;
54541 }
54542
54543
54544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
54545   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
54546   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
54547
54548   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
54549   arg2 = (Dali::Radian *)jarg2;
54550   if (arg1) (arg1)->second = *arg2;
54551 }
54552
54553
54554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
54555   void * jresult ;
54556   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
54557   Dali::Radian *result = 0 ;
54558
54559   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
54560   result = (Dali::Radian *)& ((arg1)->second);
54561   jresult = (void *)result;
54562   return jresult;
54563 }
54564
54565
54566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
54567   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
54568
54569   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
54570   {
54571     try {
54572       delete arg1;
54573     } catch (std::out_of_range& e) {
54574       {
54575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54576       };
54577     } catch (std::exception& e) {
54578       {
54579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54580       };
54581     } catch (Dali::DaliException e) {
54582       {
54583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54584       };
54585     } catch (...) {
54586       {
54587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54588       };
54589     }
54590   }
54591
54592 }
54593
54594
54595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
54596   unsigned int jresult ;
54597   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54598   bool result;
54599
54600   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54601   {
54602     try {
54603       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);
54604     } catch (std::out_of_range& e) {
54605       {
54606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54607       };
54608     } catch (std::exception& e) {
54609       {
54610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54611       };
54612     } catch (Dali::DaliException e) {
54613       {
54614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54615       };
54616     } catch (...) {
54617       {
54618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54619       };
54620     }
54621   }
54622
54623   jresult = result;
54624   return jresult;
54625 }
54626
54627
54628 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54629   unsigned long jresult ;
54630   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54631   std::size_t result;
54632
54633   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54634   {
54635     try {
54636       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);
54637     } catch (std::out_of_range& e) {
54638       {
54639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54640       };
54641     } catch (std::exception& e) {
54642       {
54643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54644       };
54645     } catch (Dali::DaliException e) {
54646       {
54647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54648       };
54649     } catch (...) {
54650       {
54651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54652       };
54653     }
54654   }
54655
54656   jresult = (unsigned long)result;
54657   return jresult;
54658 }
54659
54660
54661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54662   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54663   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
54664
54665   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54666   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
54667   {
54668     try {
54669       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54670     } catch (std::out_of_range& e) {
54671       {
54672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54673       };
54674     } catch (std::exception& e) {
54675       {
54676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54677       };
54678     } catch (Dali::DaliException e) {
54679       {
54680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54681       };
54682     } catch (...) {
54683       {
54684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54685       };
54686     }
54687   }
54688
54689 }
54690
54691
54692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54693   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54694   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
54695
54696   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54697   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
54698   {
54699     try {
54700       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54701     } catch (std::out_of_range& e) {
54702       {
54703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54704       };
54705     } catch (std::exception& e) {
54706       {
54707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54708       };
54709     } catch (Dali::DaliException e) {
54710       {
54711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54712       };
54713     } catch (...) {
54714       {
54715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54716       };
54717     }
54718   }
54719
54720 }
54721
54722
54723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54724   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54725   Dali::Actor arg2 ;
54726   Dali::PanGesture *arg3 = 0 ;
54727   Dali::Actor *argp2 ;
54728
54729   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54730   argp2 = (Dali::Actor *)jarg2;
54731   if (!argp2) {
54732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54733     return ;
54734   }
54735   arg2 = *argp2;
54736   arg3 = (Dali::PanGesture *)jarg3;
54737   if (!arg3) {
54738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
54739     return ;
54740   }
54741   {
54742     try {
54743       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
54744     } catch (std::out_of_range& e) {
54745       {
54746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54747       };
54748     } catch (std::exception& e) {
54749       {
54750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54751       };
54752     } catch (Dali::DaliException e) {
54753       {
54754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54755       };
54756     } catch (...) {
54757       {
54758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54759       };
54760     }
54761   }
54762
54763 }
54764
54765
54766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
54767   void * jresult ;
54768   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
54769
54770   {
54771     try {
54772       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
54773     } catch (std::out_of_range& e) {
54774       {
54775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54776       };
54777     } catch (std::exception& e) {
54778       {
54779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54780       };
54781     } catch (Dali::DaliException e) {
54782       {
54783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54784       };
54785     } catch (...) {
54786       {
54787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54788       };
54789     }
54790   }
54791
54792   jresult = (void *)result;
54793   return jresult;
54794 }
54795
54796
54797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
54798   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54799
54800   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54801   {
54802     try {
54803       delete arg1;
54804     } catch (std::out_of_range& e) {
54805       {
54806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54807       };
54808     } catch (std::exception& e) {
54809       {
54810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54811       };
54812     } catch (Dali::DaliException e) {
54813       {
54814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54815       };
54816     } catch (...) {
54817       {
54818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54819       };
54820     }
54821   }
54822
54823 }
54824
54825
54826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
54827   unsigned int jresult ;
54828   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54829   bool result;
54830
54831   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54832   {
54833     try {
54834       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);
54835     } catch (std::out_of_range& e) {
54836       {
54837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54838       };
54839     } catch (std::exception& e) {
54840       {
54841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54842       };
54843     } catch (Dali::DaliException e) {
54844       {
54845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54846       };
54847     } catch (...) {
54848       {
54849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54850       };
54851     }
54852   }
54853
54854   jresult = result;
54855   return jresult;
54856 }
54857
54858
54859 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54860   unsigned long jresult ;
54861   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54862   std::size_t result;
54863
54864   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54865   {
54866     try {
54867       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);
54868     } catch (std::out_of_range& e) {
54869       {
54870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54871       };
54872     } catch (std::exception& e) {
54873       {
54874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54875       };
54876     } catch (Dali::DaliException e) {
54877       {
54878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54879       };
54880     } catch (...) {
54881       {
54882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54883       };
54884     }
54885   }
54886
54887   jresult = (unsigned long)result;
54888   return jresult;
54889 }
54890
54891
54892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54893   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54894   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
54895
54896   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54897   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
54898   {
54899     try {
54900       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54901     } catch (std::out_of_range& e) {
54902       {
54903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54904       };
54905     } catch (std::exception& e) {
54906       {
54907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54908       };
54909     } catch (Dali::DaliException e) {
54910       {
54911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54912       };
54913     } catch (...) {
54914       {
54915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54916       };
54917     }
54918   }
54919
54920 }
54921
54922
54923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54924   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54925   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
54926
54927   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54928   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
54929   {
54930     try {
54931       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54932     } catch (std::out_of_range& e) {
54933       {
54934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54935       };
54936     } catch (std::exception& e) {
54937       {
54938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54939       };
54940     } catch (Dali::DaliException e) {
54941       {
54942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54943       };
54944     } catch (...) {
54945       {
54946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54947       };
54948     }
54949   }
54950
54951 }
54952
54953
54954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54955   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54956   Dali::Actor arg2 ;
54957   Dali::PinchGesture *arg3 = 0 ;
54958   Dali::Actor *argp2 ;
54959
54960   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54961   argp2 = (Dali::Actor *)jarg2;
54962   if (!argp2) {
54963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54964     return ;
54965   }
54966   arg2 = *argp2;
54967   arg3 = (Dali::PinchGesture *)jarg3;
54968   if (!arg3) {
54969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
54970     return ;
54971   }
54972   {
54973     try {
54974       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
54975     } catch (std::out_of_range& e) {
54976       {
54977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54978       };
54979     } catch (std::exception& e) {
54980       {
54981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54982       };
54983     } catch (Dali::DaliException e) {
54984       {
54985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54986       };
54987     } catch (...) {
54988       {
54989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54990       };
54991     }
54992   }
54993
54994 }
54995
54996
54997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
54998   void * jresult ;
54999   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
55000
55001   {
55002     try {
55003       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
55004     } catch (std::out_of_range& e) {
55005       {
55006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55007       };
55008     } catch (std::exception& e) {
55009       {
55010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55011       };
55012     } catch (Dali::DaliException e) {
55013       {
55014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55015       };
55016     } catch (...) {
55017       {
55018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55019       };
55020     }
55021   }
55022
55023   jresult = (void *)result;
55024   return jresult;
55025 }
55026
55027
55028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
55029   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
55030
55031   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
55032   {
55033     try {
55034       delete arg1;
55035     } catch (std::out_of_range& e) {
55036       {
55037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55038       };
55039     } catch (std::exception& e) {
55040       {
55041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55042       };
55043     } catch (Dali::DaliException e) {
55044       {
55045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55046       };
55047     } catch (...) {
55048       {
55049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55050       };
55051     }
55052   }
55053
55054 }
55055
55056
55057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
55058   unsigned int jresult ;
55059   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
55060   bool result;
55061
55062   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
55063   {
55064     try {
55065       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);
55066     } catch (std::out_of_range& e) {
55067       {
55068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55069       };
55070     } catch (std::exception& e) {
55071       {
55072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55073       };
55074     } catch (Dali::DaliException e) {
55075       {
55076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55077       };
55078     } catch (...) {
55079       {
55080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55081       };
55082     }
55083   }
55084
55085   jresult = result;
55086   return jresult;
55087 }
55088
55089
55090 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55091   unsigned long jresult ;
55092   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
55093   std::size_t result;
55094
55095   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
55096   {
55097     try {
55098       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);
55099     } catch (std::out_of_range& e) {
55100       {
55101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55102       };
55103     } catch (std::exception& e) {
55104       {
55105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55106       };
55107     } catch (Dali::DaliException e) {
55108       {
55109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55110       };
55111     } catch (...) {
55112       {
55113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55114       };
55115     }
55116   }
55117
55118   jresult = (unsigned long)result;
55119   return jresult;
55120 }
55121
55122
55123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55124   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
55125   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
55126
55127   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
55128   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
55129   {
55130     try {
55131       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55132     } catch (std::out_of_range& e) {
55133       {
55134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55135       };
55136     } catch (std::exception& e) {
55137       {
55138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55139       };
55140     } catch (Dali::DaliException e) {
55141       {
55142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55143       };
55144     } catch (...) {
55145       {
55146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55147       };
55148     }
55149   }
55150
55151 }
55152
55153
55154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55155   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
55156   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
55157
55158   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
55159   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
55160   {
55161     try {
55162       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55163     } catch (std::out_of_range& e) {
55164       {
55165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55166       };
55167     } catch (std::exception& e) {
55168       {
55169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55170       };
55171     } catch (Dali::DaliException e) {
55172       {
55173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55174       };
55175     } catch (...) {
55176       {
55177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55178       };
55179     }
55180   }
55181
55182 }
55183
55184
55185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55186   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
55187   Dali::Actor arg2 ;
55188   Dali::TapGesture *arg3 = 0 ;
55189   Dali::Actor *argp2 ;
55190
55191   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
55192   argp2 = (Dali::Actor *)jarg2;
55193   if (!argp2) {
55194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55195     return ;
55196   }
55197   arg2 = *argp2;
55198   arg3 = (Dali::TapGesture *)jarg3;
55199   if (!arg3) {
55200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
55201     return ;
55202   }
55203   {
55204     try {
55205       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
55206     } catch (std::out_of_range& e) {
55207       {
55208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55209       };
55210     } catch (std::exception& e) {
55211       {
55212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55213       };
55214     } catch (Dali::DaliException e) {
55215       {
55216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55217       };
55218     } catch (...) {
55219       {
55220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55221       };
55222     }
55223   }
55224
55225 }
55226
55227
55228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
55229   void * jresult ;
55230   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
55231
55232   {
55233     try {
55234       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
55235     } catch (std::out_of_range& e) {
55236       {
55237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55238       };
55239     } catch (std::exception& e) {
55240       {
55241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55242       };
55243     } catch (Dali::DaliException e) {
55244       {
55245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55246       };
55247     } catch (...) {
55248       {
55249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55250       };
55251     }
55252   }
55253
55254   jresult = (void *)result;
55255   return jresult;
55256 }
55257
55258
55259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
55260   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
55261
55262   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
55263   {
55264     try {
55265       delete arg1;
55266     } catch (std::out_of_range& e) {
55267       {
55268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55269       };
55270     } catch (std::exception& e) {
55271       {
55272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55273       };
55274     } catch (Dali::DaliException e) {
55275       {
55276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55277       };
55278     } catch (...) {
55279       {
55280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55281       };
55282     }
55283   }
55284
55285 }
55286
55287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
55288   unsigned int jresult ;
55289   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
55290   bool result;
55291
55292   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
55293   {
55294     try {
55295       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
55296     } catch (std::out_of_range& e) {
55297       {
55298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55299       };
55300     } catch (std::exception& e) {
55301       {
55302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55303       };
55304     } catch (Dali::DaliException e) {
55305       {
55306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55307       };
55308     } catch (...) {
55309       {
55310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55311       };
55312     }
55313   }
55314
55315   jresult = result;
55316   return jresult;
55317 }
55318
55319
55320 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
55321   unsigned long jresult ;
55322   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
55323   std::size_t result;
55324
55325   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
55326   {
55327     try {
55328       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
55329     } catch (std::out_of_range& e) {
55330       {
55331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55332       };
55333     } catch (std::exception& e) {
55334       {
55335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55336       };
55337     } catch (Dali::DaliException e) {
55338       {
55339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55340       };
55341     } catch (...) {
55342       {
55343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55344       };
55345     }
55346   }
55347
55348   jresult = (unsigned long)result;
55349   return jresult;
55350 }
55351
55352
55353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
55354   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
55355   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
55356
55357   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
55358   arg2 = (void (*)(Dali::ResourceImage))jarg2;
55359   {
55360     try {
55361       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
55362     } catch (std::out_of_range& e) {
55363       {
55364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55365       };
55366     } catch (std::exception& e) {
55367       {
55368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55369       };
55370     } catch (Dali::DaliException e) {
55371       {
55372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55373       };
55374     } catch (...) {
55375       {
55376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55377       };
55378     }
55379   }
55380
55381 }
55382
55383
55384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
55385   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
55386   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
55387
55388   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
55389   arg2 = (void (*)(Dali::ResourceImage))jarg2;
55390   {
55391     try {
55392       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
55393     } catch (std::out_of_range& e) {
55394       {
55395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55396       };
55397     } catch (std::exception& e) {
55398       {
55399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55400       };
55401     } catch (Dali::DaliException e) {
55402       {
55403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55404       };
55405     } catch (...) {
55406       {
55407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55408       };
55409     }
55410   }
55411
55412 }
55413
55414
55415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
55416   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
55417   Dali::ResourceImage arg2 ;
55418   Dali::ResourceImage *argp2 ;
55419
55420   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
55421   argp2 = (Dali::ResourceImage *)jarg2;
55422   if (!argp2) {
55423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
55424     return ;
55425   }
55426   arg2 = *argp2;
55427   {
55428     try {
55429       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
55430     } catch (std::out_of_range& e) {
55431       {
55432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55433       };
55434     } catch (std::exception& e) {
55435       {
55436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55437       };
55438     } catch (Dali::DaliException e) {
55439       {
55440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55441       };
55442     } catch (...) {
55443       {
55444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55445       };
55446     }
55447   }
55448
55449 }
55450
55451
55452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
55453   void * jresult ;
55454   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
55455
55456   {
55457     try {
55458       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
55459     } catch (std::out_of_range& e) {
55460       {
55461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55462       };
55463     } catch (std::exception& e) {
55464       {
55465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55466       };
55467     } catch (Dali::DaliException e) {
55468       {
55469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55470       };
55471     } catch (...) {
55472       {
55473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55474       };
55475     }
55476   }
55477
55478   jresult = (void *)result;
55479   return jresult;
55480 }
55481
55482
55483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
55484   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
55485
55486   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
55487   {
55488     try {
55489       delete arg1;
55490     } catch (std::out_of_range& e) {
55491       {
55492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55493       };
55494     } catch (std::exception& e) {
55495       {
55496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55497       };
55498     } catch (Dali::DaliException e) {
55499       {
55500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55501       };
55502     } catch (...) {
55503       {
55504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55505       };
55506     }
55507   }
55508
55509 }
55510
55511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
55512   unsigned int jresult ;
55513   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
55514   bool result = false;
55515
55516   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
55517   {
55518     try {
55519       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);
55520     } catch (std::out_of_range& e) {
55521       {
55522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55523       };
55524     } catch (std::exception& e) {
55525       {
55526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55527       };
55528     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
55529   }
55530   jresult = result;
55531   return jresult;
55532 }
55533
55534 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
55535   unsigned long jresult ;
55536   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
55537   std::size_t result = 0;
55538
55539   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
55540   {
55541     try {
55542       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);
55543     } catch (std::out_of_range& e) {
55544       {
55545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55546       };
55547     } catch (std::exception& e) {
55548       {
55549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55550       };
55551     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
55552   }
55553   jresult = (unsigned long)result;
55554   return jresult;
55555 }
55556
55557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
55558   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
55559   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
55560
55561   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
55562   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
55563   {
55564     try {
55565       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
55566     } catch (std::out_of_range& e) {
55567       {
55568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55569       };
55570     } catch (std::exception& e) {
55571       {
55572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55573       };
55574     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
55575   }
55576 }
55577
55578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
55579   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
55580   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
55581
55582   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
55583   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
55584   {
55585     try {
55586       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
55587     } catch (std::out_of_range& e) {
55588       {
55589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55590       };
55591     } catch (std::exception& e) {
55592       {
55593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55594       };
55595     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
55596   }
55597 }
55598
55599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
55600   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
55601   Dali::Actor arg2 ;
55602   //bool arg3 ;
55603   Dali::LayoutDirection::Type arg4 ;
55604   Dali::Actor *argp2 ;
55605
55606   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
55607   argp2 = (Dali::Actor *)jarg2;
55608   if (!argp2) {
55609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55610     return ;
55611   }
55612   arg2 = *argp2;
55613   //arg3 = jarg3 ? true : false;
55614   arg4 = (Dali::LayoutDirection::Type)jarg4;
55615   {
55616     try {
55617       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
55618     } catch (std::out_of_range& e) {
55619       {
55620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55621       };
55622     } catch (std::exception& e) {
55623       {
55624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55625       };
55626     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
55627   }
55628 }
55629
55630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
55631   void * jresult ;
55632   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
55633
55634   {
55635     try {
55636       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
55637     } catch (std::out_of_range& e) {
55638       {
55639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55640       };
55641     } catch (std::exception& e) {
55642       {
55643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55644       };
55645     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
55646   }
55647   jresult = (void *)result;
55648   return jresult;
55649 }
55650
55651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
55652   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
55653
55654   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
55655   {
55656     try {
55657       delete arg1;
55658     } catch (std::out_of_range& e) {
55659       {
55660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55661       };
55662     } catch (std::exception& e) {
55663       {
55664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55665       };
55666     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
55667   }
55668 }
55669
55670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
55671   unsigned int jresult ;
55672   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
55673   bool result;
55674
55675   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
55676   {
55677     try {
55678       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);
55679     } catch (std::out_of_range& e) {
55680       {
55681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55682       };
55683     } catch (std::exception& e) {
55684       {
55685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55686       };
55687     } catch (Dali::DaliException e) {
55688       {
55689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55690       };
55691     } catch (...) {
55692       {
55693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55694       };
55695     }
55696   }
55697
55698   jresult = result;
55699   return jresult;
55700 }
55701
55702
55703 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
55704   unsigned long jresult ;
55705   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
55706   std::size_t result;
55707
55708   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
55709   {
55710     try {
55711       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);
55712     } catch (std::out_of_range& e) {
55713       {
55714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55715       };
55716     } catch (std::exception& e) {
55717       {
55718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55719       };
55720     } catch (Dali::DaliException e) {
55721       {
55722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55723       };
55724     } catch (...) {
55725       {
55726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55727       };
55728     }
55729   }
55730
55731   jresult = (unsigned long)result;
55732   return jresult;
55733 }
55734
55735
55736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
55737   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
55738   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
55739
55740   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
55741   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
55742   {
55743     try {
55744       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
55745     } catch (std::out_of_range& e) {
55746       {
55747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55748       };
55749     } catch (std::exception& e) {
55750       {
55751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55752       };
55753     } catch (Dali::DaliException e) {
55754       {
55755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55756       };
55757     } catch (...) {
55758       {
55759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55760       };
55761     }
55762   }
55763
55764 }
55765
55766
55767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
55768   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
55769   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
55770
55771   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
55772   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
55773   {
55774     try {
55775       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
55776     } catch (std::out_of_range& e) {
55777       {
55778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55779       };
55780     } catch (std::exception& e) {
55781       {
55782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55783       };
55784     } catch (Dali::DaliException e) {
55785       {
55786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55787       };
55788     } catch (...) {
55789       {
55790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55791       };
55792     }
55793   }
55794
55795 }
55796
55797
55798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
55799   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
55800   Dali::Actor arg2 ;
55801   bool arg3 ;
55802   Dali::DevelActor::VisibilityChange::Type arg4 ;
55803   Dali::Actor *argp2 ;
55804
55805   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
55806   argp2 = (Dali::Actor *)jarg2;
55807   if (!argp2) {
55808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55809     return ;
55810   }
55811   arg2 = *argp2;
55812   arg3 = jarg3 ? true : false;
55813   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
55814   {
55815     try {
55816       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
55817     } catch (std::out_of_range& e) {
55818       {
55819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55820       };
55821     } catch (std::exception& e) {
55822       {
55823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55824       };
55825     } catch (Dali::DaliException e) {
55826       {
55827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55828       };
55829     } catch (...) {
55830       {
55831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55832       };
55833     }
55834   }
55835
55836 }
55837
55838
55839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
55840   void * jresult ;
55841   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
55842
55843   {
55844     try {
55845       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
55846     } catch (std::out_of_range& e) {
55847       {
55848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55849       };
55850     } catch (std::exception& e) {
55851       {
55852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55853       };
55854     } catch (Dali::DaliException e) {
55855       {
55856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55857       };
55858     } catch (...) {
55859       {
55860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55861       };
55862     }
55863   }
55864
55865   jresult = (void *)result;
55866   return jresult;
55867 }
55868
55869
55870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
55871   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
55872
55873   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
55874   {
55875     try {
55876       delete arg1;
55877     } catch (std::out_of_range& e) {
55878       {
55879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55880       };
55881     } catch (std::exception& e) {
55882       {
55883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55884       };
55885     } catch (Dali::DaliException e) {
55886       {
55887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55888       };
55889     } catch (...) {
55890       {
55891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55892       };
55893     }
55894   }
55895
55896 }
55897
55898
55899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
55900   void * jresult ;
55901   Dali::Timer *result = 0 ;
55902
55903   {
55904     try {
55905       result = (Dali::Timer *)new Dali::Timer();
55906     } catch (std::out_of_range& e) {
55907       {
55908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55909       };
55910     } catch (std::exception& e) {
55911       {
55912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55913       };
55914     } catch (Dali::DaliException e) {
55915       {
55916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55917       };
55918     } catch (...) {
55919       {
55920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55921       };
55922     }
55923   }
55924
55925   jresult = (void *)result;
55926   return jresult;
55927 }
55928
55929
55930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
55931   void * jresult ;
55932   unsigned int arg1 ;
55933   Dali::Timer result;
55934
55935   arg1 = (unsigned int)jarg1;
55936   {
55937     try {
55938       result = Dali::Timer::New(arg1);
55939     } catch (std::out_of_range& e) {
55940       {
55941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55942       };
55943     } catch (std::exception& e) {
55944       {
55945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55946       };
55947     } catch (Dali::DaliException e) {
55948       {
55949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55950       };
55951     } catch (...) {
55952       {
55953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55954       };
55955     }
55956   }
55957
55958   jresult = new Dali::Timer((const Dali::Timer &)result);
55959   return jresult;
55960 }
55961
55962
55963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
55964   void * jresult ;
55965   Dali::Timer *arg1 = 0 ;
55966   Dali::Timer *result = 0 ;
55967
55968   arg1 = (Dali::Timer *)jarg1;
55969   if (!arg1) {
55970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
55971     return 0;
55972   }
55973   {
55974     try {
55975       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
55976     } catch (std::out_of_range& e) {
55977       {
55978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55979       };
55980     } catch (std::exception& e) {
55981       {
55982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55983       };
55984     } catch (Dali::DaliException e) {
55985       {
55986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55987       };
55988     } catch (...) {
55989       {
55990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55991       };
55992     }
55993   }
55994
55995   jresult = (void *)result;
55996   return jresult;
55997 }
55998
55999
56000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
56001   void * jresult ;
56002   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
56003   Dali::Timer *arg2 = 0 ;
56004   Dali::Timer *result = 0 ;
56005
56006   arg1 = (Dali::Timer *)jarg1;
56007   arg2 = (Dali::Timer *)jarg2;
56008   if (!arg2) {
56009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
56010     return 0;
56011   }
56012   {
56013     try {
56014       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
56015     } catch (std::out_of_range& e) {
56016       {
56017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56018       };
56019     } catch (std::exception& e) {
56020       {
56021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56022       };
56023     } catch (Dali::DaliException e) {
56024       {
56025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56026       };
56027     } catch (...) {
56028       {
56029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56030       };
56031     }
56032   }
56033
56034   jresult = (void *)result;
56035   return jresult;
56036 }
56037
56038
56039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
56040   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
56041
56042   arg1 = (Dali::Timer *)jarg1;
56043   {
56044     try {
56045       delete arg1;
56046     } catch (std::out_of_range& e) {
56047       {
56048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56049       };
56050     } catch (std::exception& e) {
56051       {
56052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56053       };
56054     } catch (Dali::DaliException e) {
56055       {
56056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56057       };
56058     } catch (...) {
56059       {
56060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56061       };
56062     }
56063   }
56064
56065 }
56066
56067
56068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
56069   void * jresult ;
56070   Dali::BaseHandle arg1 ;
56071   Dali::BaseHandle *argp1 ;
56072   Dali::Timer result;
56073
56074   argp1 = (Dali::BaseHandle *)jarg1;
56075   if (!argp1) {
56076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
56077     return 0;
56078   }
56079   arg1 = *argp1;
56080   {
56081     try {
56082       result = Dali::Timer::DownCast(arg1);
56083     } catch (std::out_of_range& e) {
56084       {
56085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56086       };
56087     } catch (std::exception& e) {
56088       {
56089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56090       };
56091     } catch (Dali::DaliException e) {
56092       {
56093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56094       };
56095     } catch (...) {
56096       {
56097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56098       };
56099     }
56100   }
56101
56102   jresult = new Dali::Timer((const Dali::Timer &)result);
56103   return jresult;
56104 }
56105
56106
56107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
56108   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
56109
56110   arg1 = (Dali::Timer *)jarg1;
56111   {
56112     try {
56113       (arg1)->Start();
56114     } catch (std::out_of_range& e) {
56115       {
56116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56117       };
56118     } catch (std::exception& e) {
56119       {
56120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56121       };
56122     } catch (Dali::DaliException e) {
56123       {
56124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56125       };
56126     } catch (...) {
56127       {
56128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56129       };
56130     }
56131   }
56132
56133 }
56134
56135
56136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
56137   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
56138
56139   arg1 = (Dali::Timer *)jarg1;
56140   {
56141     try {
56142       (arg1)->Stop();
56143     } catch (std::out_of_range& e) {
56144       {
56145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56146       };
56147     } catch (std::exception& e) {
56148       {
56149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56150       };
56151     } catch (Dali::DaliException e) {
56152       {
56153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56154       };
56155     } catch (...) {
56156       {
56157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56158       };
56159     }
56160   }
56161
56162 }
56163
56164
56165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
56166   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
56167   unsigned int arg2 ;
56168
56169   arg1 = (Dali::Timer *)jarg1;
56170   arg2 = (unsigned int)jarg2;
56171   {
56172     try {
56173       (arg1)->SetInterval(arg2);
56174     } catch (std::out_of_range& e) {
56175       {
56176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56177       };
56178     } catch (std::exception& e) {
56179       {
56180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56181       };
56182     } catch (Dali::DaliException e) {
56183       {
56184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56185       };
56186     } catch (...) {
56187       {
56188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56189       };
56190     }
56191   }
56192
56193 }
56194
56195
56196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
56197   unsigned int jresult ;
56198   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
56199   unsigned int result;
56200
56201   arg1 = (Dali::Timer *)jarg1;
56202   {
56203     try {
56204       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
56205     } catch (std::out_of_range& e) {
56206       {
56207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56208       };
56209     } catch (std::exception& e) {
56210       {
56211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56212       };
56213     } catch (Dali::DaliException e) {
56214       {
56215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56216       };
56217     } catch (...) {
56218       {
56219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56220       };
56221     }
56222   }
56223
56224   jresult = result;
56225   return jresult;
56226 }
56227
56228
56229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
56230   unsigned int jresult ;
56231   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
56232   bool result;
56233
56234   arg1 = (Dali::Timer *)jarg1;
56235   {
56236     try {
56237       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
56238     } catch (std::out_of_range& e) {
56239       {
56240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56241       };
56242     } catch (std::exception& e) {
56243       {
56244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56245       };
56246     } catch (Dali::DaliException e) {
56247       {
56248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56249       };
56250     } catch (...) {
56251       {
56252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56253       };
56254     }
56255   }
56256
56257   jresult = result;
56258   return jresult;
56259 }
56260
56261
56262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
56263   void * jresult ;
56264   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
56265   Dali::Timer::TimerSignalType *result = 0 ;
56266
56267   arg1 = (Dali::Timer *)jarg1;
56268   {
56269     try {
56270       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
56271     } catch (std::out_of_range& e) {
56272       {
56273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56274       };
56275     } catch (std::exception& e) {
56276       {
56277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56278       };
56279     } catch (Dali::DaliException e) {
56280       {
56281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56282       };
56283     } catch (...) {
56284       {
56285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56286       };
56287     }
56288   }
56289
56290   jresult = (void *)result;
56291   return jresult;
56292 }
56293
56294
56295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
56296   unsigned int jresult ;
56297   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56298   bool result;
56299
56300   arg1 = (Dali::Signal< bool () > *)jarg1;
56301   {
56302     try {
56303       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
56304     } catch (std::out_of_range& e) {
56305       {
56306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56307       };
56308     } catch (std::exception& e) {
56309       {
56310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56311       };
56312     } catch (Dali::DaliException e) {
56313       {
56314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56315       };
56316     } catch (...) {
56317       {
56318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56319       };
56320     }
56321   }
56322
56323   jresult = result;
56324   return jresult;
56325 }
56326
56327
56328 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
56329   unsigned long jresult ;
56330   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56331   std::size_t result;
56332
56333   arg1 = (Dali::Signal< bool () > *)jarg1;
56334   {
56335     try {
56336       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
56337     } catch (std::out_of_range& e) {
56338       {
56339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56340       };
56341     } catch (std::exception& e) {
56342       {
56343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56344       };
56345     } catch (Dali::DaliException e) {
56346       {
56347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56348       };
56349     } catch (...) {
56350       {
56351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56352       };
56353     }
56354   }
56355
56356   jresult = (unsigned long)result;
56357   return jresult;
56358 }
56359
56360
56361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
56362   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56363   bool (*arg2)() = (bool (*)()) 0 ;
56364
56365   arg1 = (Dali::Signal< bool () > *)jarg1;
56366   arg2 = (bool (*)())jarg2;
56367   {
56368     try {
56369       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
56370     } catch (std::out_of_range& e) {
56371       {
56372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56373       };
56374     } catch (std::exception& e) {
56375       {
56376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56377       };
56378     } catch (Dali::DaliException e) {
56379       {
56380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56381       };
56382     } catch (...) {
56383       {
56384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56385       };
56386     }
56387   }
56388
56389 }
56390
56391
56392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
56393   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56394   bool (*arg2)() = (bool (*)()) 0 ;
56395
56396   arg1 = (Dali::Signal< bool () > *)jarg1;
56397   arg2 = (bool (*)())jarg2;
56398   {
56399     try {
56400       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
56401     } catch (std::out_of_range& e) {
56402       {
56403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56404       };
56405     } catch (std::exception& e) {
56406       {
56407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56408       };
56409     } catch (Dali::DaliException e) {
56410       {
56411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56412       };
56413     } catch (...) {
56414       {
56415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56416       };
56417     }
56418   }
56419
56420 }
56421
56422
56423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
56424   unsigned int jresult ;
56425   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56426   bool result;
56427
56428   arg1 = (Dali::Signal< bool () > *)jarg1;
56429   {
56430     try {
56431       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
56432     } catch (std::out_of_range& e) {
56433       {
56434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56435       };
56436     } catch (std::exception& e) {
56437       {
56438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56439       };
56440     } catch (Dali::DaliException e) {
56441       {
56442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56443       };
56444     } catch (...) {
56445       {
56446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56447       };
56448     }
56449   }
56450
56451   jresult = result;
56452   return jresult;
56453 }
56454
56455
56456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
56457   void * jresult ;
56458   Dali::Signal< bool () > *result = 0 ;
56459
56460   {
56461     try {
56462       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
56463     } catch (std::out_of_range& e) {
56464       {
56465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56466       };
56467     } catch (std::exception& e) {
56468       {
56469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56470       };
56471     } catch (Dali::DaliException e) {
56472       {
56473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56474       };
56475     } catch (...) {
56476       {
56477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56478       };
56479     }
56480   }
56481
56482   jresult = (void *)result;
56483   return jresult;
56484 }
56485
56486
56487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
56488   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56489
56490   arg1 = (Dali::Signal< bool () > *)jarg1;
56491   {
56492     try {
56493       delete arg1;
56494     } catch (std::out_of_range& e) {
56495       {
56496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56497       };
56498     } catch (std::exception& e) {
56499       {
56500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56501       };
56502     } catch (Dali::DaliException e) {
56503       {
56504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56505       };
56506     } catch (...) {
56507       {
56508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56509       };
56510     }
56511   }
56512
56513 }
56514
56515
56516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
56517   int jresult ;
56518   int result;
56519
56520   {
56521     try {
56522       result = (int)Dali::Toolkit::Visual::Property::TYPE;
56523     } catch (std::out_of_range& e) {
56524       {
56525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56526       };
56527     } catch (std::exception& e) {
56528       {
56529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56530       };
56531     } catch (Dali::DaliException e) {
56532       {
56533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56534       };
56535     } catch (...) {
56536       {
56537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56538       };
56539     }
56540   }
56541
56542   jresult = (int)result;
56543   return jresult;
56544 }
56545
56546
56547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
56548   int jresult ;
56549   int result;
56550
56551   {
56552     try {
56553       result = (int)Dali::Toolkit::Visual::Property::SHADER;
56554     } catch (std::out_of_range& e) {
56555       {
56556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56557       };
56558     } catch (std::exception& e) {
56559       {
56560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56561       };
56562     } catch (Dali::DaliException e) {
56563       {
56564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56565       };
56566     } catch (...) {
56567       {
56568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56569       };
56570     }
56571   }
56572
56573   jresult = (int)result;
56574   return jresult;
56575 }
56576
56577
56578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
56579   int jresult ;
56580   int result;
56581
56582   {
56583     try {
56584       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
56585     } catch (std::out_of_range& e) {
56586       {
56587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56588       };
56589     } catch (std::exception& e) {
56590       {
56591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56592       };
56593     } catch (Dali::DaliException e) {
56594       {
56595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56596       };
56597     } catch (...) {
56598       {
56599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56600       };
56601     }
56602   }
56603
56604   jresult = (int)result;
56605   return jresult;
56606 }
56607
56608
56609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
56610   int jresult ;
56611   int result;
56612
56613   {
56614     try {
56615       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
56616     } catch (std::out_of_range& e) {
56617       {
56618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56619       };
56620     } catch (std::exception& e) {
56621       {
56622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56623       };
56624     } catch (Dali::DaliException e) {
56625       {
56626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56627       };
56628     } catch (...) {
56629       {
56630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56631       };
56632     }
56633   }
56634
56635   jresult = (int)result;
56636   return jresult;
56637 }
56638
56639
56640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
56641   int jresult ;
56642   int result;
56643
56644   {
56645     try {
56646       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
56647     } catch (std::out_of_range& e) {
56648       {
56649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56650       };
56651     } catch (std::exception& e) {
56652       {
56653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56654       };
56655     } catch (Dali::DaliException e) {
56656       {
56657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56658       };
56659     } catch (...) {
56660       {
56661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56662       };
56663     }
56664   }
56665
56666   jresult = (int)result;
56667   return jresult;
56668 }
56669
56670
56671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
56672   int jresult ;
56673   int result;
56674
56675   {
56676     try {
56677       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
56678     } catch (std::out_of_range& e) {
56679       {
56680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56681       };
56682     } catch (std::exception& e) {
56683       {
56684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56685       };
56686     } catch (Dali::DaliException e) {
56687       {
56688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56689       };
56690     } catch (...) {
56691       {
56692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56693       };
56694     }
56695   }
56696
56697   jresult = (int)result;
56698   return jresult;
56699 }
56700
56701
56702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
56703   int jresult ;
56704   int result;
56705
56706   {
56707     try {
56708       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
56709     } catch (std::out_of_range& e) {
56710       {
56711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56712       };
56713     } catch (std::exception& e) {
56714       {
56715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56716       };
56717     } catch (Dali::DaliException e) {
56718       {
56719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56720       };
56721     } catch (...) {
56722       {
56723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56724       };
56725     }
56726   }
56727
56728   jresult = (int)result;
56729   return jresult;
56730 }
56731
56732
56733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
56734   int jresult ;
56735   int result;
56736
56737   {
56738     try {
56739       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
56740     } catch (std::out_of_range& e) {
56741       {
56742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56743       };
56744     } catch (std::exception& e) {
56745       {
56746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56747       };
56748     } catch (Dali::DaliException e) {
56749       {
56750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56751       };
56752     } catch (...) {
56753       {
56754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56755       };
56756     }
56757   }
56758
56759   jresult = (int)result;
56760   return jresult;
56761 }
56762
56763
56764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
56765   int jresult ;
56766   int result;
56767
56768   {
56769     try {
56770       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
56771     } catch (std::out_of_range& e) {
56772       {
56773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56774       };
56775     } catch (std::exception& e) {
56776       {
56777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56778       };
56779     } catch (Dali::DaliException e) {
56780       {
56781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56782       };
56783     } catch (...) {
56784       {
56785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56786       };
56787     }
56788   }
56789
56790   jresult = (int)result;
56791   return jresult;
56792 }
56793
56794
56795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
56796   int jresult ;
56797   int result;
56798
56799   {
56800     try {
56801       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
56802     } catch (std::out_of_range& e) {
56803       {
56804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56805       };
56806     } catch (std::exception& e) {
56807       {
56808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56809       };
56810     } catch (Dali::DaliException e) {
56811       {
56812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56813       };
56814     } catch (...) {
56815       {
56816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56817       };
56818     }
56819   }
56820
56821   jresult = (int)result;
56822   return jresult;
56823 }
56824
56825
56826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
56827   int jresult ;
56828   int result;
56829
56830   {
56831     try {
56832       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
56833     } catch (std::out_of_range& e) {
56834       {
56835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56836       };
56837     } catch (std::exception& e) {
56838       {
56839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56840       };
56841     } catch (Dali::DaliException e) {
56842       {
56843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56844       };
56845     } catch (...) {
56846       {
56847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56848       };
56849     }
56850   }
56851
56852   jresult = (int)result;
56853   return jresult;
56854 }
56855
56856
56857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
56858   int jresult ;
56859   int result;
56860
56861   {
56862     try {
56863       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
56864     } catch (std::out_of_range& e) {
56865       {
56866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56867       };
56868     } catch (std::exception& e) {
56869       {
56870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56871       };
56872     } catch (Dali::DaliException e) {
56873       {
56874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56875       };
56876     } catch (...) {
56877       {
56878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56879       };
56880     }
56881   }
56882
56883   jresult = (int)result;
56884   return jresult;
56885 }
56886
56887
56888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
56889   int jresult ;
56890   int result;
56891
56892   {
56893     try {
56894       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
56895     } catch (std::out_of_range& e) {
56896       {
56897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56898       };
56899     } catch (std::exception& e) {
56900       {
56901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56902       };
56903     } catch (Dali::DaliException e) {
56904       {
56905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56906       };
56907     } catch (...) {
56908       {
56909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56910       };
56911     }
56912   }
56913
56914   jresult = (int)result;
56915   return jresult;
56916 }
56917
56918
56919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
56920   int jresult ;
56921   int result;
56922
56923   {
56924     try {
56925       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
56926     } catch (std::out_of_range& e) {
56927       {
56928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56929       };
56930     } catch (std::exception& e) {
56931       {
56932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56933       };
56934     } catch (Dali::DaliException e) {
56935       {
56936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56937       };
56938     } catch (...) {
56939       {
56940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56941       };
56942     }
56943   }
56944
56945   jresult = (int)result;
56946   return jresult;
56947 }
56948
56949
56950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
56951   int jresult ;
56952   int result;
56953
56954   {
56955     try {
56956       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
56957     } catch (std::out_of_range& e) {
56958       {
56959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56960       };
56961     } catch (std::exception& e) {
56962       {
56963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56964       };
56965     } catch (Dali::DaliException e) {
56966       {
56967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56968       };
56969     } catch (...) {
56970       {
56971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56972       };
56973     }
56974   }
56975
56976   jresult = (int)result;
56977   return jresult;
56978 }
56979
56980
56981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
56982   int jresult ;
56983   int result;
56984
56985   {
56986     try {
56987       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
56988     } catch (std::out_of_range& e) {
56989       {
56990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56991       };
56992     } catch (std::exception& e) {
56993       {
56994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56995       };
56996     } catch (Dali::DaliException e) {
56997       {
56998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56999       };
57000     } catch (...) {
57001       {
57002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57003       };
57004     }
57005   }
57006
57007   jresult = (int)result;
57008   return jresult;
57009 }
57010
57011
57012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
57013   int jresult ;
57014   int result;
57015
57016   {
57017     try {
57018       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
57019     } catch (std::out_of_range& e) {
57020       {
57021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57022       };
57023     } catch (std::exception& e) {
57024       {
57025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57026       };
57027     } catch (Dali::DaliException e) {
57028       {
57029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57030       };
57031     } catch (...) {
57032       {
57033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57034       };
57035     }
57036   }
57037
57038   jresult = (int)result;
57039   return jresult;
57040 }
57041
57042
57043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
57044   int jresult ;
57045   int result;
57046
57047   {
57048     try {
57049       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
57050     } catch (std::out_of_range& e) {
57051       {
57052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57053       };
57054     } catch (std::exception& e) {
57055       {
57056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57057       };
57058     } catch (Dali::DaliException e) {
57059       {
57060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57061       };
57062     } catch (...) {
57063       {
57064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57065       };
57066     }
57067   }
57068
57069   jresult = (int)result;
57070   return jresult;
57071 }
57072
57073
57074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
57075   int jresult ;
57076   int result;
57077
57078   {
57079     try {
57080       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
57081     } catch (std::out_of_range& e) {
57082       {
57083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57084       };
57085     } catch (std::exception& e) {
57086       {
57087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57088       };
57089     } catch (Dali::DaliException e) {
57090       {
57091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57092       };
57093     } catch (...) {
57094       {
57095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57096       };
57097     }
57098   }
57099
57100   jresult = (int)result;
57101   return jresult;
57102 }
57103
57104
57105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
57106   int jresult ;
57107   int result;
57108
57109   {
57110     try {
57111       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
57112     } catch (std::out_of_range& e) {
57113       {
57114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57115       };
57116     } catch (std::exception& e) {
57117       {
57118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57119       };
57120     } catch (Dali::DaliException e) {
57121       {
57122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57123       };
57124     } catch (...) {
57125       {
57126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57127       };
57128     }
57129   }
57130
57131   jresult = (int)result;
57132   return jresult;
57133 }
57134
57135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
57136   int jresult ;
57137   int result;
57138
57139   {
57140     try {
57141       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
57142     } catch (std::out_of_range& e) {
57143       {
57144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57145       };
57146     } catch (std::exception& e) {
57147       {
57148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57149       };
57150     } catch (Dali::DaliException e) {
57151       {
57152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57153       };
57154     } catch (...) {
57155       {
57156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57157       };
57158     }
57159   }
57160
57161   jresult = (int)result;
57162   return jresult;
57163 }
57164
57165
57166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
57167   int jresult ;
57168   int result;
57169   {
57170     try
57171     {
57172       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
57173     } catch (std::out_of_range& e) {
57174       {
57175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57176       };
57177     } catch (std::exception& e) {
57178       {
57179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57180       };
57181     } catch (Dali::DaliException e) {
57182       {
57183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57184       };
57185     } catch (...) {
57186       {
57187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57188       };
57189     }
57190   }
57191
57192   jresult = (int)result;
57193   return jresult;
57194 }
57195
57196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
57197   int jresult ;
57198   int result;
57199   {
57200     try
57201     {
57202       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
57203     } catch (std::out_of_range& e) {
57204       {
57205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57206       };
57207     } catch (std::exception& e) {
57208       {
57209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57210       };
57211     } catch (Dali::DaliException e) {
57212       {
57213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57214       };
57215     } catch (...) {
57216       {
57217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57218       };
57219     }
57220   }
57221
57222   jresult = (int)result;
57223   return jresult;
57224 }
57225
57226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
57227   int jresult ;
57228   int result;
57229   {
57230     try
57231     {
57232       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
57233     } catch (std::out_of_range& e) {
57234       {
57235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57236       };
57237     } catch (std::exception& e) {
57238       {
57239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57240       };
57241     } catch (Dali::DaliException e) {
57242       {
57243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57244       };
57245     } catch (...) {
57246       {
57247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57248       };
57249     }
57250   }
57251
57252   jresult = (int)result;
57253   return jresult;
57254 }
57255
57256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
57257   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
57258 }
57259
57260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
57261   int jresult ;
57262   int result;
57263   {
57264     try
57265     {
57266       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
57267     } catch (std::out_of_range& e) {
57268       {
57269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57270       };
57271     } catch (std::exception& e) {
57272       {
57273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57274       };
57275     } catch (Dali::DaliException e) {
57276       {
57277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57278       };
57279     } catch (...) {
57280       {
57281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57282       };
57283     }
57284   }
57285
57286   jresult = (int)result;
57287   return jresult;
57288 }
57289
57290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
57291   int jresult ;
57292   int result;
57293   {
57294     try
57295     {
57296       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
57297     } catch (std::out_of_range& e) {
57298       {
57299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57300       };
57301     } catch (std::exception& e) {
57302       {
57303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57304       };
57305     } catch (Dali::DaliException e) {
57306       {
57307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57308       };
57309     } catch (...) {
57310       {
57311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57312       };
57313     }
57314   }
57315
57316   jresult = (int)result;
57317   return jresult;
57318 }
57319
57320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
57321   int jresult ;
57322   int result;
57323
57324   {
57325     try {
57326       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
57327     } catch (std::out_of_range& e) {
57328       {
57329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57330       };
57331     } catch (std::exception& e) {
57332       {
57333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57334       };
57335     } catch (Dali::DaliException e) {
57336       {
57337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57338       };
57339     } catch (...) {
57340       {
57341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57342       };
57343     }
57344   }
57345
57346   jresult = (int)result;
57347   return jresult;
57348 }
57349
57350
57351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
57352   int jresult ;
57353   int result;
57354
57355   {
57356     try {
57357       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
57358     } catch (std::out_of_range& e) {
57359       {
57360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57361       };
57362     } catch (std::exception& e) {
57363       {
57364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57365       };
57366     } catch (Dali::DaliException e) {
57367       {
57368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57369       };
57370     } catch (...) {
57371       {
57372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57373       };
57374     }
57375   }
57376
57377   jresult = (int)result;
57378   return jresult;
57379 }
57380
57381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
57382   int jresult ;
57383   int result;
57384   {
57385     try
57386     {
57387       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
57388     } catch (std::out_of_range& e) {
57389       {
57390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57391       };
57392     } catch (std::exception& e) {
57393       {
57394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57395       };
57396     } catch (...) {
57397       {
57398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57399       };
57400     }
57401   }
57402   jresult = (int)result;
57403   return jresult;
57404 }
57405
57406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
57407   int jresult ;
57408   int result;
57409   {
57410     try
57411     {
57412       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
57413     } catch (std::out_of_range& e) {
57414       {
57415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57416       };
57417     } catch (std::exception& e) {
57418       {
57419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57420       };
57421     } catch (...) {
57422       {
57423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57424       };
57425     }
57426   }
57427   jresult = (int)result;
57428   return jresult;
57429 }
57430
57431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
57432   int jresult ;
57433   int result;
57434   {
57435     try
57436     {
57437       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
57438     } catch (std::out_of_range& e) {
57439       {
57440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57441       };
57442     } catch (std::exception& e) {
57443       {
57444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57445       };
57446     } catch (...) {
57447       {
57448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57449       };
57450     }
57451   }
57452   jresult = (int)result;
57453   return jresult;
57454 }
57455
57456
57457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
57458   int jresult ;
57459   int result;
57460   {
57461     try
57462     {
57463       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
57464     } catch (std::out_of_range& e) {
57465       {
57466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57467       };
57468     } catch (std::exception& e) {
57469       {
57470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57471       };
57472     } catch (...) {
57473       {
57474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57475       };
57476     }
57477   }
57478   jresult = (int)result;
57479   return jresult;
57480 }
57481
57482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
57483   int jresult ;
57484   int result;
57485   {
57486     try
57487     {
57488       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
57489     } catch (std::out_of_range& e) {
57490       {
57491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57492       };
57493     } catch (std::exception& e) {
57494       {
57495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57496       };
57497     } catch (...) {
57498       {
57499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57500       };
57501     }
57502   }
57503   jresult = (int)result;
57504   return jresult;
57505 }
57506
57507
57508
57509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
57510   int jresult ;
57511   int result;
57512
57513   {
57514     try {
57515       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
57516     } catch (std::out_of_range& e) {
57517       {
57518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57519       };
57520     } catch (std::exception& e) {
57521       {
57522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57523       };
57524     } catch (Dali::DaliException e) {
57525       {
57526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57527       };
57528     } catch (...) {
57529       {
57530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57531       };
57532     }
57533   }
57534
57535   jresult = (int)result;
57536   return jresult;
57537 }
57538
57539
57540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
57541   int jresult ;
57542   int result;
57543
57544   {
57545     try {
57546       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
57547     } catch (std::out_of_range& e) {
57548       {
57549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57550       };
57551     } catch (std::exception& e) {
57552       {
57553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57554       };
57555     } catch (Dali::DaliException e) {
57556       {
57557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57558       };
57559     } catch (...) {
57560       {
57561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57562       };
57563     }
57564   }
57565
57566   jresult = (int)result;
57567   return jresult;
57568 }
57569
57570
57571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
57572   int jresult ;
57573   int result;
57574
57575   {
57576     try {
57577       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
57578     } catch (std::out_of_range& e) {
57579       {
57580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57581       };
57582     } catch (std::exception& e) {
57583       {
57584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57585       };
57586     } catch (Dali::DaliException e) {
57587       {
57588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57589       };
57590     } catch (...) {
57591       {
57592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57593       };
57594     }
57595   }
57596
57597   jresult = (int)result;
57598   return jresult;
57599 }
57600
57601
57602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
57603   int jresult ;
57604   int result;
57605
57606   {
57607     try {
57608       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
57609     } catch (std::out_of_range& e) {
57610       {
57611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57612       };
57613     } catch (std::exception& e) {
57614       {
57615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57616       };
57617     } catch (Dali::DaliException e) {
57618       {
57619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57620       };
57621     } catch (...) {
57622       {
57623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57624       };
57625     }
57626   }
57627
57628   jresult = (int)result;
57629   return jresult;
57630 }
57631
57632
57633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
57634   int jresult ;
57635   int result;
57636
57637   {
57638     try {
57639       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
57640     } catch (std::out_of_range& e) {
57641       {
57642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57643       };
57644     } catch (std::exception& e) {
57645       {
57646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57647       };
57648     } catch (Dali::DaliException e) {
57649       {
57650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57651       };
57652     } catch (...) {
57653       {
57654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57655       };
57656     }
57657   }
57658
57659   jresult = (int)result;
57660   return jresult;
57661 }
57662
57663
57664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
57665   int jresult ;
57666   int result;
57667
57668   {
57669     try {
57670       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
57671     } catch (std::out_of_range& e) {
57672       {
57673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57674       };
57675     } catch (std::exception& e) {
57676       {
57677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57678       };
57679     } catch (Dali::DaliException e) {
57680       {
57681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57682       };
57683     } catch (...) {
57684       {
57685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57686       };
57687     }
57688   }
57689
57690   jresult = (int)result;
57691   return jresult;
57692 }
57693
57694
57695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
57696   int jresult ;
57697   int result;
57698
57699   {
57700     try {
57701       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
57702     } catch (std::out_of_range& e) {
57703       {
57704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57705       };
57706     } catch (std::exception& e) {
57707       {
57708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57709       };
57710     } catch (Dali::DaliException e) {
57711       {
57712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57713       };
57714     } catch (...) {
57715       {
57716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57717       };
57718     }
57719   }
57720
57721   jresult = (int)result;
57722   return jresult;
57723 }
57724
57725 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
57726   int jresult ;
57727   int result;
57728
57729   {
57730     try {
57731       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
57732     } catch (std::out_of_range& e) {
57733       {
57734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57735       };
57736     } catch (std::exception& e) {
57737       {
57738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57739       };
57740     } catch (...) {
57741       {
57742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57743       };
57744     }
57745   }
57746   jresult = (int)result;
57747   return jresult;
57748 }
57749
57750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
57751   int jresult ;
57752   int result;
57753
57754   {
57755     try {
57756       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
57757     } catch (std::out_of_range& e) {
57758       {
57759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57760       };
57761     } catch (std::exception& e) {
57762       {
57763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57764       };
57765     } catch (Dali::DaliException e) {
57766       {
57767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57768       };
57769     } catch (...) {
57770       {
57771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57772       };
57773     }
57774   }
57775
57776   jresult = (int)result;
57777   return jresult;
57778 }
57779
57780
57781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
57782   int jresult ;
57783   int result;
57784
57785   {
57786     try {
57787       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
57788     } catch (std::out_of_range& e) {
57789       {
57790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57791       };
57792     } catch (std::exception& e) {
57793       {
57794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57795       };
57796     } catch (Dali::DaliException e) {
57797       {
57798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57799       };
57800     } catch (...) {
57801       {
57802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57803       };
57804     }
57805   }
57806
57807   jresult = (int)result;
57808   return jresult;
57809 }
57810
57811
57812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
57813   int jresult ;
57814   int result;
57815
57816   {
57817     try {
57818       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
57819     } catch (std::out_of_range& e) {
57820       {
57821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57822       };
57823     } catch (std::exception& e) {
57824       {
57825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57826       };
57827     } catch (Dali::DaliException e) {
57828       {
57829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57830       };
57831     } catch (...) {
57832       {
57833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57834       };
57835     }
57836   }
57837
57838   jresult = (int)result;
57839   return jresult;
57840 }
57841
57842
57843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
57844   int jresult ;
57845   int result;
57846
57847   {
57848     try {
57849       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
57850     } catch (std::out_of_range& e) {
57851       {
57852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57853       };
57854     } catch (std::exception& e) {
57855       {
57856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57857       };
57858     } catch (Dali::DaliException e) {
57859       {
57860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57861       };
57862     } catch (...) {
57863       {
57864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57865       };
57866     }
57867   }
57868
57869   jresult = (int)result;
57870   return jresult;
57871 }
57872
57873
57874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
57875   int jresult ;
57876   int result;
57877
57878   {
57879     try {
57880       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
57881     } catch (std::out_of_range& e) {
57882       {
57883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57884       };
57885     } catch (std::exception& e) {
57886       {
57887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57888       };
57889     } catch (Dali::DaliException e) {
57890       {
57891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57892       };
57893     } catch (...) {
57894       {
57895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57896       };
57897     }
57898   }
57899
57900   jresult = (int)result;
57901   return jresult;
57902 }
57903
57904
57905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
57906   int jresult ;
57907   int result;
57908
57909   {
57910     try {
57911       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
57912     } catch (std::out_of_range& e) {
57913       {
57914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57915       };
57916     } catch (std::exception& e) {
57917       {
57918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57919       };
57920     } catch (Dali::DaliException e) {
57921       {
57922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57923       };
57924     } catch (...) {
57925       {
57926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57927       };
57928     }
57929   }
57930
57931   jresult = (int)result;
57932   return jresult;
57933 }
57934
57935
57936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
57937   int jresult ;
57938   int result;
57939
57940   {
57941     try {
57942       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
57943     } catch (std::out_of_range& e) {
57944       {
57945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57946       };
57947     } catch (std::exception& e) {
57948       {
57949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57950       };
57951     } catch (Dali::DaliException e) {
57952       {
57953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57954       };
57955     } catch (...) {
57956       {
57957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57958       };
57959     }
57960   }
57961
57962   jresult = (int)result;
57963   return jresult;
57964 }
57965
57966
57967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
57968   int jresult ;
57969   int result;
57970
57971   {
57972     try {
57973       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
57974     } catch (std::out_of_range& e) {
57975       {
57976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57977       };
57978     } catch (std::exception& e) {
57979       {
57980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57981       };
57982     } catch (Dali::DaliException e) {
57983       {
57984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57985       };
57986     } catch (...) {
57987       {
57988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57989       };
57990     }
57991   }
57992
57993   jresult = (int)result;
57994   return jresult;
57995 }
57996
57997
57998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
57999   int jresult ;
58000   int result;
58001
58002   {
58003     try {
58004       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
58005     } catch (std::out_of_range& e) {
58006       {
58007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58008       };
58009     } catch (std::exception& e) {
58010       {
58011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58012       };
58013     } catch (Dali::DaliException e) {
58014       {
58015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58016       };
58017     } catch (...) {
58018       {
58019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58020       };
58021     }
58022   }
58023
58024   jresult = (int)result;
58025   return jresult;
58026 }
58027
58028
58029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
58030   int jresult ;
58031   int result;
58032
58033   {
58034     try {
58035       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
58036     } catch (std::out_of_range& e) {
58037       {
58038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58039       };
58040     } catch (std::exception& e) {
58041       {
58042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58043       };
58044     } catch (Dali::DaliException e) {
58045       {
58046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58047       };
58048     } catch (...) {
58049       {
58050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58051       };
58052     }
58053   }
58054
58055   jresult = (int)result;
58056   return jresult;
58057 }
58058
58059
58060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
58061   int jresult ;
58062   int result;
58063
58064   {
58065     try {
58066       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
58067     } catch (std::out_of_range& e) {
58068       {
58069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58070       };
58071     } catch (std::exception& e) {
58072       {
58073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58074       };
58075     } catch (Dali::DaliException e) {
58076       {
58077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58078       };
58079     } catch (...) {
58080       {
58081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58082       };
58083     }
58084   }
58085
58086   jresult = (int)result;
58087   return jresult;
58088 }
58089
58090
58091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
58092   int jresult ;
58093   int result;
58094
58095   {
58096     try {
58097       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
58098     } catch (std::out_of_range& e) {
58099       {
58100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58101       };
58102     } catch (std::exception& e) {
58103       {
58104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58105       };
58106     } catch (Dali::DaliException e) {
58107       {
58108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58109       };
58110     } catch (...) {
58111       {
58112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58113       };
58114     }
58115   }
58116
58117   jresult = (int)result;
58118   return jresult;
58119 }
58120
58121
58122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
58123   int jresult ;
58124   int result;
58125
58126   {
58127     try {
58128       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
58129     } catch (std::out_of_range& e) {
58130       {
58131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58132       };
58133     } catch (std::exception& e) {
58134       {
58135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58136       };
58137     } catch (Dali::DaliException e) {
58138       {
58139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58140       };
58141     } catch (...) {
58142       {
58143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58144       };
58145     }
58146   }
58147
58148   jresult = (int)result;
58149   return jresult;
58150 }
58151
58152
58153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
58154   int jresult ;
58155   int result;
58156
58157   {
58158     try {
58159       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
58160     } catch (std::out_of_range& e) {
58161       {
58162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58163       };
58164     } catch (std::exception& e) {
58165       {
58166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58167       };
58168     } catch (Dali::DaliException e) {
58169       {
58170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58171       };
58172     } catch (...) {
58173       {
58174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58175       };
58176     }
58177   }
58178
58179   jresult = (int)result;
58180   return jresult;
58181 }
58182
58183
58184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
58185   int jresult ;
58186   int result;
58187
58188   {
58189     try {
58190       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
58191     } catch (std::out_of_range& e) {
58192       {
58193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58194       };
58195     } catch (std::exception& e) {
58196       {
58197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58198       };
58199     } catch (Dali::DaliException e) {
58200       {
58201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58202       };
58203     } catch (...) {
58204       {
58205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58206       };
58207     }
58208   }
58209
58210   jresult = (int)result;
58211   return jresult;
58212 }
58213
58214
58215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
58216   int jresult ;
58217   int result;
58218
58219   {
58220     try {
58221       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
58222     } catch (std::out_of_range& e) {
58223       {
58224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58225       };
58226     } catch (std::exception& e) {
58227       {
58228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58229       };
58230     } catch (Dali::DaliException e) {
58231       {
58232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58233       };
58234     } catch (...) {
58235       {
58236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58237       };
58238     }
58239   }
58240
58241   jresult = (int)result;
58242   return jresult;
58243 }
58244
58245
58246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
58247   int jresult ;
58248   int result;
58249
58250   {
58251     try {
58252       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
58253     } catch (std::out_of_range& e) {
58254       {
58255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58256       };
58257     } catch (std::exception& e) {
58258       {
58259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58260       };
58261     } catch (Dali::DaliException e) {
58262       {
58263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58264       };
58265     } catch (...) {
58266       {
58267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58268       };
58269     }
58270   }
58271
58272   jresult = (int)result;
58273   return jresult;
58274 }
58275
58276
58277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
58278   int jresult ;
58279   int result;
58280
58281   {
58282     try {
58283       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
58284     } catch (std::out_of_range& e) {
58285       {
58286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58287       };
58288     } catch (std::exception& e) {
58289       {
58290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58291       };
58292     } catch (Dali::DaliException e) {
58293       {
58294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58295       };
58296     } catch (...) {
58297       {
58298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58299       };
58300     }
58301   }
58302
58303   jresult = (int)result;
58304   return jresult;
58305 }
58306
58307
58308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
58309   int jresult ;
58310   int result;
58311
58312   {
58313     try {
58314       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
58315     } catch (std::out_of_range& e) {
58316       {
58317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58318       };
58319     } catch (std::exception& e) {
58320       {
58321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58322       };
58323     } catch (Dali::DaliException e) {
58324       {
58325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58326       };
58327     } catch (...) {
58328       {
58329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58330       };
58331     }
58332   }
58333
58334   jresult = (int)result;
58335   return jresult;
58336 }
58337
58338
58339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
58340   int jresult ;
58341   int result;
58342
58343   {
58344     try {
58345       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
58346     } catch (std::out_of_range& e) {
58347       {
58348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58349       };
58350     } catch (std::exception& e) {
58351       {
58352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58353       };
58354     } catch (Dali::DaliException e) {
58355       {
58356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58357       };
58358     } catch (...) {
58359       {
58360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58361       };
58362     }
58363   }
58364
58365   jresult = (int)result;
58366   return jresult;
58367 }
58368
58369
58370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
58371   int jresult ;
58372   int result;
58373
58374   {
58375     try {
58376       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
58377     } catch (std::out_of_range& e) {
58378       {
58379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58380       };
58381     } catch (std::exception& e) {
58382       {
58383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58384       };
58385     } catch (Dali::DaliException e) {
58386       {
58387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58388       };
58389     } catch (...) {
58390       {
58391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58392       };
58393     }
58394   }
58395
58396   jresult = (int)result;
58397   return jresult;
58398 }
58399
58400
58401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
58402   int jresult ;
58403   int result;
58404
58405   {
58406     try {
58407       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
58408     } catch (std::out_of_range& e) {
58409       {
58410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58411       };
58412     } catch (std::exception& e) {
58413       {
58414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58415       };
58416     } catch (Dali::DaliException e) {
58417       {
58418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58419       };
58420     } catch (...) {
58421       {
58422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58423       };
58424     }
58425   }
58426
58427   jresult = (int)result;
58428   return jresult;
58429 }
58430
58431
58432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
58433   int jresult ;
58434   int result;
58435
58436   {
58437     try {
58438       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
58439     } catch (std::out_of_range& e) {
58440       {
58441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58442       };
58443     } catch (std::exception& e) {
58444       {
58445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58446       };
58447     } catch (Dali::DaliException e) {
58448       {
58449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58450       };
58451     } catch (...) {
58452       {
58453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58454       };
58455     }
58456   }
58457
58458   jresult = (int)result;
58459   return jresult;
58460 }
58461
58462
58463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
58464   int jresult ;
58465   int result;
58466
58467   {
58468     try {
58469       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
58470     } catch (std::out_of_range& e) {
58471       {
58472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58473       };
58474     } catch (std::exception& e) {
58475       {
58476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58477       };
58478     } catch (Dali::DaliException e) {
58479       {
58480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58481       };
58482     } catch (...) {
58483       {
58484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58485       };
58486     }
58487   }
58488
58489   jresult = (int)result;
58490   return jresult;
58491 }
58492
58493
58494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
58495   int jresult ;
58496   int result;
58497
58498   {
58499     try {
58500       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
58501     } catch (std::out_of_range& e) {
58502       {
58503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58504       };
58505     } catch (std::exception& e) {
58506       {
58507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58508       };
58509     } catch (Dali::DaliException e) {
58510       {
58511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58512       };
58513     } catch (...) {
58514       {
58515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58516       };
58517     }
58518   }
58519
58520   jresult = (int)result;
58521   return jresult;
58522 }
58523
58524
58525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
58526   int jresult ;
58527   int result;
58528
58529   {
58530     try {
58531       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
58532     } catch (std::out_of_range& e) {
58533       {
58534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58535       };
58536     } catch (std::exception& e) {
58537       {
58538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58539       };
58540     } catch (Dali::DaliException e) {
58541       {
58542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58543       };
58544     } catch (...) {
58545       {
58546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58547       };
58548     }
58549   }
58550
58551   jresult = (int)result;
58552   return jresult;
58553 }
58554
58555
58556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
58557   int jresult ;
58558   int result;
58559
58560   {
58561     try {
58562       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
58563     } catch (std::out_of_range& e) {
58564       {
58565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58566       };
58567     } catch (std::exception& e) {
58568       {
58569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58570       };
58571     } catch (Dali::DaliException e) {
58572       {
58573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58574       };
58575     } catch (...) {
58576       {
58577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58578       };
58579     }
58580   }
58581
58582   jresult = (int)result;
58583   return jresult;
58584 }
58585
58586
58587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
58588   int jresult ;
58589   int result;
58590
58591   {
58592     try {
58593       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
58594     } catch (std::out_of_range& e) {
58595       {
58596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58597       };
58598     } catch (std::exception& e) {
58599       {
58600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58601       };
58602     } catch (Dali::DaliException e) {
58603       {
58604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58605       };
58606     } catch (...) {
58607       {
58608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58609       };
58610     }
58611   }
58612
58613   jresult = (int)result;
58614   return jresult;
58615 }
58616
58617
58618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
58619   void * jresult ;
58620   Dali::Toolkit::Builder *result = 0 ;
58621
58622   {
58623     try {
58624       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
58625     } catch (std::out_of_range& e) {
58626       {
58627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58628       };
58629     } catch (std::exception& e) {
58630       {
58631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58632       };
58633     } catch (Dali::DaliException e) {
58634       {
58635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58636       };
58637     } catch (...) {
58638       {
58639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58640       };
58641     }
58642   }
58643
58644   jresult = (void *)result;
58645   return jresult;
58646 }
58647
58648
58649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
58650   void * jresult ;
58651   Dali::Toolkit::Builder result;
58652
58653   {
58654     try {
58655       result = Dali::Toolkit::Builder::New();
58656     } catch (std::out_of_range& e) {
58657       {
58658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58659       };
58660     } catch (std::exception& e) {
58661       {
58662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58663       };
58664     } catch (Dali::DaliException e) {
58665       {
58666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58667       };
58668     } catch (...) {
58669       {
58670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58671       };
58672     }
58673   }
58674
58675   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
58676   return jresult;
58677 }
58678
58679
58680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
58681   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58682
58683   arg1 = (Dali::Toolkit::Builder *)jarg1;
58684   {
58685     try {
58686       delete arg1;
58687     } catch (std::out_of_range& e) {
58688       {
58689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58690       };
58691     } catch (std::exception& e) {
58692       {
58693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58694       };
58695     } catch (Dali::DaliException e) {
58696       {
58697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58698       };
58699     } catch (...) {
58700       {
58701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58702       };
58703     }
58704   }
58705
58706 }
58707
58708
58709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
58710   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58711   std::string *arg2 = 0 ;
58712   Dali::Toolkit::Builder::UIFormat arg3 ;
58713
58714   arg1 = (Dali::Toolkit::Builder *)jarg1;
58715   if (!jarg2) {
58716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58717     return ;
58718   }
58719   std::string arg2_str(jarg2);
58720   arg2 = &arg2_str;
58721   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
58722   {
58723     try {
58724       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
58725     } catch (std::out_of_range& e) {
58726       {
58727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58728       };
58729     } catch (std::exception& e) {
58730       {
58731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58732       };
58733     } catch (Dali::DaliException e) {
58734       {
58735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58736       };
58737     } catch (...) {
58738       {
58739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58740       };
58741     }
58742   }
58743
58744
58745   //argout typemap for const std::string&
58746
58747 }
58748
58749
58750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
58751   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58752   std::string *arg2 = 0 ;
58753
58754   arg1 = (Dali::Toolkit::Builder *)jarg1;
58755   if (!jarg2) {
58756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58757     return ;
58758   }
58759   std::string arg2_str(jarg2);
58760   arg2 = &arg2_str;
58761   {
58762     try {
58763       (arg1)->LoadFromString((std::string const &)*arg2);
58764     } catch (std::out_of_range& e) {
58765       {
58766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58767       };
58768     } catch (std::exception& e) {
58769       {
58770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58771       };
58772     } catch (Dali::DaliException e) {
58773       {
58774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58775       };
58776     } catch (...) {
58777       {
58778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58779       };
58780     }
58781   }
58782
58783
58784   //argout typemap for const std::string&
58785
58786 }
58787
58788
58789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
58790   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58791   Dali::Property::Map *arg2 = 0 ;
58792
58793   arg1 = (Dali::Toolkit::Builder *)jarg1;
58794   arg2 = (Dali::Property::Map *)jarg2;
58795   if (!arg2) {
58796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58797     return ;
58798   }
58799   {
58800     try {
58801       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
58802     } catch (std::out_of_range& e) {
58803       {
58804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58805       };
58806     } catch (std::exception& e) {
58807       {
58808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58809       };
58810     } catch (Dali::DaliException e) {
58811       {
58812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58813       };
58814     } catch (...) {
58815       {
58816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58817       };
58818     }
58819   }
58820
58821 }
58822
58823
58824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
58825   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58826   std::string *arg2 = 0 ;
58827   Dali::Property::Value *arg3 = 0 ;
58828
58829   arg1 = (Dali::Toolkit::Builder *)jarg1;
58830   if (!jarg2) {
58831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58832     return ;
58833   }
58834   std::string arg2_str(jarg2);
58835   arg2 = &arg2_str;
58836   arg3 = (Dali::Property::Value *)jarg3;
58837   if (!arg3) {
58838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
58839     return ;
58840   }
58841   {
58842     try {
58843       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
58844     } catch (std::out_of_range& e) {
58845       {
58846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58847       };
58848     } catch (std::exception& e) {
58849       {
58850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58851       };
58852     } catch (Dali::DaliException e) {
58853       {
58854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58855       };
58856     } catch (...) {
58857       {
58858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58859       };
58860     }
58861   }
58862
58863
58864   //argout typemap for const std::string&
58865
58866 }
58867
58868
58869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
58870   void * jresult ;
58871   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58872   Dali::Property::Map *result = 0 ;
58873
58874   arg1 = (Dali::Toolkit::Builder *)jarg1;
58875   {
58876     try {
58877       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
58878     } catch (std::out_of_range& e) {
58879       {
58880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58881       };
58882     } catch (std::exception& e) {
58883       {
58884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58885       };
58886     } catch (Dali::DaliException e) {
58887       {
58888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58889       };
58890     } catch (...) {
58891       {
58892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58893       };
58894     }
58895   }
58896
58897   jresult = (void *)result;
58898   return jresult;
58899 }
58900
58901
58902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
58903   void * jresult ;
58904   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58905   std::string *arg2 = 0 ;
58906   Dali::Property::Value *result = 0 ;
58907
58908   arg1 = (Dali::Toolkit::Builder *)jarg1;
58909   if (!jarg2) {
58910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58911     return 0;
58912   }
58913   std::string arg2_str(jarg2);
58914   arg2 = &arg2_str;
58915   {
58916     try {
58917       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
58918     } catch (std::out_of_range& e) {
58919       {
58920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58921       };
58922     } catch (std::exception& e) {
58923       {
58924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58925       };
58926     } catch (Dali::DaliException e) {
58927       {
58928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58929       };
58930     } catch (...) {
58931       {
58932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58933       };
58934     }
58935   }
58936
58937   jresult = (void *)result;
58938
58939   //argout typemap for const std::string&
58940
58941   return jresult;
58942 }
58943
58944
58945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
58946   void * jresult ;
58947   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58948   std::string *arg2 = 0 ;
58949   Dali::Animation result;
58950
58951   arg1 = (Dali::Toolkit::Builder *)jarg1;
58952   if (!jarg2) {
58953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58954     return 0;
58955   }
58956   std::string arg2_str(jarg2);
58957   arg2 = &arg2_str;
58958   {
58959     try {
58960       result = (arg1)->CreateAnimation((std::string const &)*arg2);
58961     } catch (std::out_of_range& e) {
58962       {
58963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58964       };
58965     } catch (std::exception& e) {
58966       {
58967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58968       };
58969     } catch (Dali::DaliException e) {
58970       {
58971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58972       };
58973     } catch (...) {
58974       {
58975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58976       };
58977     }
58978   }
58979
58980   jresult = new Dali::Animation((const Dali::Animation &)result);
58981
58982   //argout typemap for const std::string&
58983
58984   return jresult;
58985 }
58986
58987
58988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58989   void * jresult ;
58990   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58991   std::string *arg2 = 0 ;
58992   Dali::Property::Map *arg3 = 0 ;
58993   Dali::Animation result;
58994
58995   arg1 = (Dali::Toolkit::Builder *)jarg1;
58996   if (!jarg2) {
58997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58998     return 0;
58999   }
59000   std::string arg2_str(jarg2);
59001   arg2 = &arg2_str;
59002   arg3 = (Dali::Property::Map *)jarg3;
59003   if (!arg3) {
59004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59005     return 0;
59006   }
59007   {
59008     try {
59009       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
59010     } catch (std::out_of_range& e) {
59011       {
59012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59013       };
59014     } catch (std::exception& e) {
59015       {
59016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59017       };
59018     } catch (Dali::DaliException e) {
59019       {
59020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59021       };
59022     } catch (...) {
59023       {
59024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59025       };
59026     }
59027   }
59028
59029   jresult = new Dali::Animation((const Dali::Animation &)result);
59030
59031   //argout typemap for const std::string&
59032
59033   return jresult;
59034 }
59035
59036
59037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
59038   void * jresult ;
59039   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59040   std::string *arg2 = 0 ;
59041   Dali::Actor arg3 ;
59042   Dali::Actor *argp3 ;
59043   Dali::Animation result;
59044
59045   arg1 = (Dali::Toolkit::Builder *)jarg1;
59046   if (!jarg2) {
59047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59048     return 0;
59049   }
59050   std::string arg2_str(jarg2);
59051   arg2 = &arg2_str;
59052   argp3 = (Dali::Actor *)jarg3;
59053   if (!argp3) {
59054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59055     return 0;
59056   }
59057   arg3 = *argp3;
59058   {
59059     try {
59060       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
59061     } catch (std::out_of_range& e) {
59062       {
59063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59064       };
59065     } catch (std::exception& e) {
59066       {
59067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59068       };
59069     } catch (Dali::DaliException e) {
59070       {
59071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59072       };
59073     } catch (...) {
59074       {
59075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59076       };
59077     }
59078   }
59079
59080   jresult = new Dali::Animation((const Dali::Animation &)result);
59081
59082   //argout typemap for const std::string&
59083
59084   return jresult;
59085 }
59086
59087
59088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
59089   void * jresult ;
59090   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59091   std::string *arg2 = 0 ;
59092   Dali::Property::Map *arg3 = 0 ;
59093   Dali::Actor arg4 ;
59094   Dali::Actor *argp4 ;
59095   Dali::Animation result;
59096
59097   arg1 = (Dali::Toolkit::Builder *)jarg1;
59098   if (!jarg2) {
59099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59100     return 0;
59101   }
59102   std::string arg2_str(jarg2);
59103   arg2 = &arg2_str;
59104   arg3 = (Dali::Property::Map *)jarg3;
59105   if (!arg3) {
59106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59107     return 0;
59108   }
59109   argp4 = (Dali::Actor *)jarg4;
59110   if (!argp4) {
59111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59112     return 0;
59113   }
59114   arg4 = *argp4;
59115   {
59116     try {
59117       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
59118     } catch (std::out_of_range& e) {
59119       {
59120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59121       };
59122     } catch (std::exception& e) {
59123       {
59124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59125       };
59126     } catch (Dali::DaliException e) {
59127       {
59128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59129       };
59130     } catch (...) {
59131       {
59132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59133       };
59134     }
59135   }
59136
59137   jresult = new Dali::Animation((const Dali::Animation &)result);
59138
59139   //argout typemap for const std::string&
59140
59141   return jresult;
59142 }
59143
59144
59145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
59146   void * jresult ;
59147   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59148   std::string *arg2 = 0 ;
59149   Dali::BaseHandle result;
59150
59151   arg1 = (Dali::Toolkit::Builder *)jarg1;
59152   if (!jarg2) {
59153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59154     return 0;
59155   }
59156   std::string arg2_str(jarg2);
59157   arg2 = &arg2_str;
59158   {
59159     try {
59160       result = (arg1)->Create((std::string const &)*arg2);
59161     } catch (std::out_of_range& e) {
59162       {
59163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59164       };
59165     } catch (std::exception& e) {
59166       {
59167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59168       };
59169     } catch (Dali::DaliException e) {
59170       {
59171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59172       };
59173     } catch (...) {
59174       {
59175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59176       };
59177     }
59178   }
59179
59180   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
59181
59182   //argout typemap for const std::string&
59183
59184   return jresult;
59185 }
59186
59187
59188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
59189   void * jresult ;
59190   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59191   std::string *arg2 = 0 ;
59192   Dali::Property::Map *arg3 = 0 ;
59193   Dali::BaseHandle result;
59194
59195   arg1 = (Dali::Toolkit::Builder *)jarg1;
59196   if (!jarg2) {
59197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59198     return 0;
59199   }
59200   std::string arg2_str(jarg2);
59201   arg2 = &arg2_str;
59202   arg3 = (Dali::Property::Map *)jarg3;
59203   if (!arg3) {
59204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59205     return 0;
59206   }
59207   {
59208     try {
59209       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
59210     } catch (std::out_of_range& e) {
59211       {
59212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59213       };
59214     } catch (std::exception& e) {
59215       {
59216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59217       };
59218     } catch (Dali::DaliException e) {
59219       {
59220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59221       };
59222     } catch (...) {
59223       {
59224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59225       };
59226     }
59227   }
59228
59229   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
59230
59231   //argout typemap for const std::string&
59232
59233   return jresult;
59234 }
59235
59236
59237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
59238   void * jresult ;
59239   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59240   std::string *arg2 = 0 ;
59241   Dali::BaseHandle result;
59242
59243   arg1 = (Dali::Toolkit::Builder *)jarg1;
59244   if (!jarg2) {
59245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59246     return 0;
59247   }
59248   std::string arg2_str(jarg2);
59249   arg2 = &arg2_str;
59250   {
59251     try {
59252       result = (arg1)->CreateFromJson((std::string const &)*arg2);
59253     } catch (std::out_of_range& e) {
59254       {
59255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59256       };
59257     } catch (std::exception& e) {
59258       {
59259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59260       };
59261     } catch (Dali::DaliException e) {
59262       {
59263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59264       };
59265     } catch (...) {
59266       {
59267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59268       };
59269     }
59270   }
59271
59272   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
59273
59274   //argout typemap for const std::string&
59275
59276   return jresult;
59277 }
59278
59279
59280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
59281   unsigned int jresult ;
59282   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59283   std::string *arg2 = 0 ;
59284   Dali::Handle *arg3 = 0 ;
59285   bool result;
59286
59287   arg1 = (Dali::Toolkit::Builder *)jarg1;
59288   if (!jarg2) {
59289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59290     return 0;
59291   }
59292   std::string arg2_str(jarg2);
59293   arg2 = &arg2_str;
59294   arg3 = (Dali::Handle *)jarg3;
59295   if (!arg3) {
59296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
59297     return 0;
59298   }
59299   {
59300     try {
59301       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
59302     } catch (std::out_of_range& e) {
59303       {
59304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59305       };
59306     } catch (std::exception& e) {
59307       {
59308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59309       };
59310     } catch (Dali::DaliException e) {
59311       {
59312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59313       };
59314     } catch (...) {
59315       {
59316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59317       };
59318     }
59319   }
59320
59321   jresult = result;
59322
59323   //argout typemap for const std::string&
59324
59325   return jresult;
59326 }
59327
59328
59329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
59330   unsigned int jresult ;
59331   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59332   Dali::Handle *arg2 = 0 ;
59333   std::string *arg3 = 0 ;
59334   bool result;
59335
59336   arg1 = (Dali::Toolkit::Builder *)jarg1;
59337   arg2 = (Dali::Handle *)jarg2;
59338   if (!arg2) {
59339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
59340     return 0;
59341   }
59342   if (!jarg3) {
59343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59344     return 0;
59345   }
59346   std::string arg3_str(jarg3);
59347   arg3 = &arg3_str;
59348   {
59349     try {
59350       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
59351     } catch (std::out_of_range& e) {
59352       {
59353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59354       };
59355     } catch (std::exception& e) {
59356       {
59357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59358       };
59359     } catch (Dali::DaliException e) {
59360       {
59361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59362       };
59363     } catch (...) {
59364       {
59365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59366       };
59367     }
59368   }
59369
59370   jresult = result;
59371
59372   //argout typemap for const std::string&
59373
59374   return jresult;
59375 }
59376
59377
59378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
59379   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59380   Dali::Actor arg2 ;
59381   Dali::Actor *argp2 ;
59382
59383   arg1 = (Dali::Toolkit::Builder *)jarg1;
59384   argp2 = (Dali::Actor *)jarg2;
59385   if (!argp2) {
59386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59387     return ;
59388   }
59389   arg2 = *argp2;
59390   {
59391     try {
59392       (arg1)->AddActors(arg2);
59393     } catch (std::out_of_range& e) {
59394       {
59395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59396       };
59397     } catch (std::exception& e) {
59398       {
59399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59400       };
59401     } catch (Dali::DaliException e) {
59402       {
59403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59404       };
59405     } catch (...) {
59406       {
59407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59408       };
59409     }
59410   }
59411
59412 }
59413
59414
59415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
59416   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59417   std::string *arg2 = 0 ;
59418   Dali::Actor arg3 ;
59419   Dali::Actor *argp3 ;
59420
59421   arg1 = (Dali::Toolkit::Builder *)jarg1;
59422   if (!jarg2) {
59423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59424     return ;
59425   }
59426   std::string arg2_str(jarg2);
59427   arg2 = &arg2_str;
59428   argp3 = (Dali::Actor *)jarg3;
59429   if (!argp3) {
59430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59431     return ;
59432   }
59433   arg3 = *argp3;
59434   {
59435     try {
59436       (arg1)->AddActors((std::string const &)*arg2,arg3);
59437     } catch (std::out_of_range& e) {
59438       {
59439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59440       };
59441     } catch (std::exception& e) {
59442       {
59443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59444       };
59445     } catch (Dali::DaliException e) {
59446       {
59447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59448       };
59449     } catch (...) {
59450       {
59451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59452       };
59453     }
59454   }
59455
59456
59457   //argout typemap for const std::string&
59458
59459 }
59460
59461
59462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
59463   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59464   std::string *arg2 = 0 ;
59465
59466   arg1 = (Dali::Toolkit::Builder *)jarg1;
59467   if (!jarg2) {
59468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59469     return ;
59470   }
59471   std::string arg2_str(jarg2);
59472   arg2 = &arg2_str;
59473   {
59474     try {
59475       (arg1)->CreateRenderTask((std::string const &)*arg2);
59476     } catch (std::out_of_range& e) {
59477       {
59478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59479       };
59480     } catch (std::exception& e) {
59481       {
59482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59483       };
59484     } catch (Dali::DaliException e) {
59485       {
59486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59487       };
59488     } catch (...) {
59489       {
59490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59491       };
59492     }
59493   }
59494
59495
59496   //argout typemap for const std::string&
59497
59498 }
59499
59500
59501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
59502   void * jresult ;
59503   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59504   std::string *arg2 = 0 ;
59505   Dali::Path result;
59506
59507   arg1 = (Dali::Toolkit::Builder *)jarg1;
59508   if (!jarg2) {
59509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59510     return 0;
59511   }
59512   std::string arg2_str(jarg2);
59513   arg2 = &arg2_str;
59514   {
59515     try {
59516       result = (arg1)->GetPath((std::string const &)*arg2);
59517     } catch (std::out_of_range& e) {
59518       {
59519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59520       };
59521     } catch (std::exception& e) {
59522       {
59523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59524       };
59525     } catch (Dali::DaliException e) {
59526       {
59527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59528       };
59529     } catch (...) {
59530       {
59531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59532       };
59533     }
59534   }
59535
59536   jresult = new Dali::Path((const Dali::Path &)result);
59537
59538   //argout typemap for const std::string&
59539
59540   return jresult;
59541 }
59542
59543
59544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
59545   void * jresult ;
59546   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59547   std::string *arg2 = 0 ;
59548   Dali::PathConstrainer result;
59549
59550   arg1 = (Dali::Toolkit::Builder *)jarg1;
59551   if (!jarg2) {
59552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59553     return 0;
59554   }
59555   std::string arg2_str(jarg2);
59556   arg2 = &arg2_str;
59557   {
59558     try {
59559       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
59560     } catch (std::out_of_range& e) {
59561       {
59562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59563       };
59564     } catch (std::exception& e) {
59565       {
59566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59567       };
59568     } catch (Dali::DaliException e) {
59569       {
59570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59571       };
59572     } catch (...) {
59573       {
59574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59575       };
59576     }
59577   }
59578
59579   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
59580
59581   //argout typemap for const std::string&
59582
59583   return jresult;
59584 }
59585
59586
59587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
59588   void * jresult ;
59589   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59590   std::string *arg2 = 0 ;
59591   Dali::LinearConstrainer result;
59592
59593   arg1 = (Dali::Toolkit::Builder *)jarg1;
59594   if (!jarg2) {
59595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59596     return 0;
59597   }
59598   std::string arg2_str(jarg2);
59599   arg2 = &arg2_str;
59600   {
59601     try {
59602       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
59603     } catch (std::out_of_range& e) {
59604       {
59605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59606       };
59607     } catch (std::exception& e) {
59608       {
59609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59610       };
59611     } catch (Dali::DaliException e) {
59612       {
59613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59614       };
59615     } catch (...) {
59616       {
59617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59618       };
59619     }
59620   }
59621
59622   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
59623
59624   //argout typemap for const std::string&
59625
59626   return jresult;
59627 }
59628
59629
59630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
59631   void * jresult ;
59632   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59633   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
59634
59635   arg1 = (Dali::Toolkit::Builder *)jarg1;
59636   {
59637     try {
59638       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
59639     } catch (std::out_of_range& e) {
59640       {
59641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59642       };
59643     } catch (std::exception& e) {
59644       {
59645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59646       };
59647     } catch (Dali::DaliException e) {
59648       {
59649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59650       };
59651     } catch (...) {
59652       {
59653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59654       };
59655     }
59656   }
59657
59658   jresult = (void *)result;
59659   return jresult;
59660 }
59661
59662
59663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
59664   void * jresult ;
59665   Dali::Toolkit::TransitionData *result = 0 ;
59666
59667   {
59668     try {
59669       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
59670     } catch (std::out_of_range& e) {
59671       {
59672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59673       };
59674     } catch (std::exception& e) {
59675       {
59676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59677       };
59678     } catch (Dali::DaliException e) {
59679       {
59680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59681       };
59682     } catch (...) {
59683       {
59684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59685       };
59686     }
59687   }
59688
59689   jresult = (void *)result;
59690   return jresult;
59691 }
59692
59693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
59694   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59695
59696   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59697   {
59698     try {
59699       delete arg1;
59700     } catch (std::out_of_range& e) {
59701       {
59702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59703       };
59704     } catch (std::exception& e) {
59705       {
59706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59707       };
59708     } catch (Dali::DaliException e) {
59709       {
59710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59711       };
59712     } catch (...) {
59713       {
59714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59715       };
59716     }
59717   }
59718
59719 }
59720
59721
59722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
59723   void * jresult ;
59724   Dali::Property::Map *arg1 = 0 ;
59725   Dali::Toolkit::TransitionData result;
59726
59727   arg1 = (Dali::Property::Map *)jarg1;
59728   if (!arg1) {
59729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59730     return 0;
59731   }
59732   {
59733     try {
59734       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
59735     } catch (std::out_of_range& e) {
59736       {
59737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59738       };
59739     } catch (std::exception& e) {
59740       {
59741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59742       };
59743     } catch (Dali::DaliException e) {
59744       {
59745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59746       };
59747     } catch (...) {
59748       {
59749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59750       };
59751     }
59752   }
59753
59754   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59755   return jresult;
59756 }
59757
59758
59759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
59760   void * jresult ;
59761   Dali::Property::Array *arg1 = 0 ;
59762   Dali::Toolkit::TransitionData result;
59763
59764   arg1 = (Dali::Property::Array *)jarg1;
59765   if (!arg1) {
59766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
59767     return 0;
59768   }
59769   {
59770     try {
59771       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
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 = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59792   return jresult;
59793 }
59794
59795
59796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
59797   void * jresult ;
59798   Dali::BaseHandle arg1 ;
59799   Dali::BaseHandle *argp1 ;
59800   Dali::Toolkit::TransitionData result;
59801
59802   argp1 = (Dali::BaseHandle *)jarg1;
59803   if (!argp1) {
59804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59805     return 0;
59806   }
59807   arg1 = *argp1;
59808   {
59809     try {
59810       result = Dali::Toolkit::TransitionData::DownCast(arg1);
59811     } catch (std::out_of_range& e) {
59812       {
59813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59814       };
59815     } catch (std::exception& e) {
59816       {
59817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59818       };
59819     } catch (Dali::DaliException e) {
59820       {
59821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59822       };
59823     } catch (...) {
59824       {
59825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59826       };
59827     }
59828   }
59829
59830   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59831   return jresult;
59832 }
59833
59834
59835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
59836   void * jresult ;
59837   Dali::Toolkit::TransitionData *arg1 = 0 ;
59838   Dali::Toolkit::TransitionData *result = 0 ;
59839
59840   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59841   if (!arg1) {
59842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59843     return 0;
59844   }
59845   {
59846     try {
59847       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
59848     } catch (std::out_of_range& e) {
59849       {
59850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59851       };
59852     } catch (std::exception& e) {
59853       {
59854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59855       };
59856     } catch (Dali::DaliException e) {
59857       {
59858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59859       };
59860     } catch (...) {
59861       {
59862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59863       };
59864     }
59865   }
59866
59867   jresult = (void *)result;
59868   return jresult;
59869 }
59870
59871
59872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
59873   void * jresult ;
59874   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59875   Dali::Toolkit::TransitionData *arg2 = 0 ;
59876   Dali::Toolkit::TransitionData *result = 0 ;
59877
59878   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59879   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
59880   if (!arg2) {
59881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59882     return 0;
59883   }
59884   {
59885     try {
59886       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
59887     } catch (std::out_of_range& e) {
59888       {
59889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59890       };
59891     } catch (std::exception& e) {
59892       {
59893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59894       };
59895     } catch (Dali::DaliException e) {
59896       {
59897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59898       };
59899     } catch (...) {
59900       {
59901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59902       };
59903     }
59904   }
59905
59906   jresult = (void *)result;
59907   return jresult;
59908 }
59909
59910
59911 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
59912   unsigned long jresult ;
59913   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59914   size_t result;
59915
59916   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59917   {
59918     try {
59919       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
59920     } catch (std::out_of_range& e) {
59921       {
59922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59923       };
59924     } catch (std::exception& e) {
59925       {
59926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59927       };
59928     } catch (Dali::DaliException e) {
59929       {
59930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59931       };
59932     } catch (...) {
59933       {
59934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59935       };
59936     }
59937   }
59938
59939   jresult = (unsigned long)result;
59940   return jresult;
59941 }
59942
59943
59944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
59945   void * jresult ;
59946   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59947   size_t arg2 ;
59948   Dali::Property::Map result;
59949
59950   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59951   arg2 = (size_t)jarg2;
59952   {
59953     try {
59954       result = (arg1)->GetAnimatorAt(arg2);
59955     } catch (std::out_of_range& e) {
59956       {
59957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59958       };
59959     } catch (std::exception& e) {
59960       {
59961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59962       };
59963     } catch (Dali::DaliException e) {
59964       {
59965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59966       };
59967     } catch (...) {
59968       {
59969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59970       };
59971     }
59972   }
59973
59974   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
59975   return jresult;
59976 }
59977
59978
59979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
59980   int jresult ;
59981   int result;
59982
59983   {
59984     try {
59985       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
59986     } catch (std::out_of_range& e) {
59987       {
59988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59989       };
59990     } catch (std::exception& e) {
59991       {
59992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59993       };
59994     } catch (Dali::DaliException e) {
59995       {
59996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59997       };
59998     } catch (...) {
59999       {
60000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60001       };
60002     }
60003   }
60004
60005   jresult = (int)result;
60006   return jresult;
60007 }
60008
60009
60010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
60011   int jresult ;
60012   int result;
60013
60014   {
60015     try {
60016       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
60017     } catch (std::out_of_range& e) {
60018       {
60019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60020       };
60021     } catch (std::exception& e) {
60022       {
60023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60024       };
60025     } catch (Dali::DaliException e) {
60026       {
60027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60028       };
60029     } catch (...) {
60030       {
60031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60032       };
60033     }
60034   }
60035
60036   jresult = (int)result;
60037   return jresult;
60038 }
60039
60040
60041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
60042   int jresult ;
60043   int result;
60044
60045   {
60046     try {
60047       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
60048     } catch (std::out_of_range& e) {
60049       {
60050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60051       };
60052     } catch (std::exception& e) {
60053       {
60054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60055       };
60056     } catch (Dali::DaliException e) {
60057       {
60058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60059       };
60060     } catch (...) {
60061       {
60062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60063       };
60064     }
60065   }
60066
60067   jresult = (int)result;
60068   return jresult;
60069 }
60070
60071
60072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
60073   int jresult ;
60074   int result;
60075
60076   {
60077     try {
60078       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
60079     } catch (std::out_of_range& e) {
60080       {
60081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60082       };
60083     } catch (std::exception& e) {
60084       {
60085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60086       };
60087     } catch (Dali::DaliException e) {
60088       {
60089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60090       };
60091     } catch (...) {
60092       {
60093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60094       };
60095     }
60096   }
60097
60098   jresult = (int)result;
60099   return jresult;
60100 }
60101
60102
60103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
60104   int jresult ;
60105   int result;
60106
60107   {
60108     try {
60109       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
60110     } catch (std::out_of_range& e) {
60111       {
60112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60113       };
60114     } catch (std::exception& e) {
60115       {
60116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60117       };
60118     } catch (Dali::DaliException e) {
60119       {
60120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60121       };
60122     } catch (...) {
60123       {
60124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60125       };
60126     }
60127   }
60128
60129   jresult = (int)result;
60130   return jresult;
60131 }
60132
60133
60134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
60135   int jresult ;
60136   int result;
60137
60138   {
60139     try {
60140       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
60141     } catch (std::out_of_range& e) {
60142       {
60143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60144       };
60145     } catch (std::exception& e) {
60146       {
60147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60148       };
60149     } catch (Dali::DaliException e) {
60150       {
60151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60152       };
60153     } catch (...) {
60154       {
60155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60156       };
60157     }
60158   }
60159
60160   jresult = (int)result;
60161   return jresult;
60162 }
60163
60164
60165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
60166   int jresult ;
60167   int result;
60168
60169   {
60170     try {
60171       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
60172     } catch (std::out_of_range& e) {
60173       {
60174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60175       };
60176     } catch (std::exception& e) {
60177       {
60178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60179       };
60180     } catch (Dali::DaliException e) {
60181       {
60182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60183       };
60184     } catch (...) {
60185       {
60186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60187       };
60188     }
60189   }
60190
60191   jresult = (int)result;
60192   return jresult;
60193 }
60194
60195
60196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
60197   int jresult ;
60198   int result;
60199
60200   {
60201     try {
60202       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
60203     } catch (std::out_of_range& e) {
60204       {
60205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60206       };
60207     } catch (std::exception& e) {
60208       {
60209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60210       };
60211     } catch (Dali::DaliException e) {
60212       {
60213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60214       };
60215     } catch (...) {
60216       {
60217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60218       };
60219     }
60220   }
60221
60222   jresult = (int)result;
60223   return jresult;
60224 }
60225
60226
60227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
60228   int jresult ;
60229   int result;
60230
60231   {
60232     try {
60233       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
60234     } catch (std::out_of_range& e) {
60235       {
60236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60237       };
60238     } catch (std::exception& e) {
60239       {
60240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60241       };
60242     } catch (Dali::DaliException e) {
60243       {
60244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60245       };
60246     } catch (...) {
60247       {
60248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60249       };
60250     }
60251   }
60252
60253   jresult = (int)result;
60254   return jresult;
60255 }
60256
60257
60258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
60259   int jresult ;
60260   int result;
60261
60262   {
60263     try {
60264       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
60265     } catch (std::out_of_range& e) {
60266       {
60267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60268       };
60269     } catch (std::exception& e) {
60270       {
60271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60272       };
60273     } catch (Dali::DaliException e) {
60274       {
60275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60276       };
60277     } catch (...) {
60278       {
60279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60280       };
60281     }
60282   }
60283
60284   jresult = (int)result;
60285   return jresult;
60286 }
60287
60288
60289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
60290   int jresult ;
60291   int result;
60292
60293   {
60294     try {
60295       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
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_TOOLTIP_TAIL_VISIBILITY_get() {
60321   int jresult ;
60322   int result;
60323
60324   {
60325     try {
60326       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
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_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
60352   int jresult ;
60353   int result;
60354
60355   {
60356     try {
60357       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
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_TOOLTIP_TAIL_BELOW_VISUAL_get() {
60383   int jresult ;
60384   int result;
60385
60386   {
60387     try {
60388       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
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 void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
60414   void * jresult ;
60415   Dali::Toolkit::Control result;
60416
60417   {
60418     try {
60419       result = Dali::Toolkit::Internal::Control::New();
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 = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
60440   return jresult;
60441 }
60442
60443
60444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
60445   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60446   std::string *arg2 = 0 ;
60447
60448   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60449   if (!jarg2) {
60450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60451     return ;
60452   }
60453   std::string arg2_str(jarg2);
60454   arg2 = &arg2_str;
60455   {
60456     try {
60457       (arg1)->SetStyleName((std::string const &)*arg2);
60458     } catch (std::out_of_range& e) {
60459       {
60460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60461       };
60462     } catch (std::exception& e) {
60463       {
60464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60465       };
60466     } catch (Dali::DaliException e) {
60467       {
60468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60469       };
60470     } catch (...) {
60471       {
60472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60473       };
60474     }
60475   }
60476
60477
60478   //argout typemap for const std::string&
60479
60480 }
60481
60482
60483 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
60484   char * jresult ;
60485   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60486   std::string *result = 0 ;
60487
60488   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60489   {
60490     try {
60491       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
60492     } catch (std::out_of_range& e) {
60493       {
60494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60495       };
60496     } catch (std::exception& e) {
60497       {
60498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60499       };
60500     } catch (Dali::DaliException e) {
60501       {
60502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60503       };
60504     } catch (...) {
60505       {
60506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60507       };
60508     }
60509   }
60510
60511   jresult = SWIG_csharp_string_callback(result->c_str());
60512   return jresult;
60513 }
60514
60515
60516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
60517   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60518   Dali::Vector4 *arg2 = 0 ;
60519
60520   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60521   arg2 = (Dali::Vector4 *)jarg2;
60522   if (!arg2) {
60523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
60524     return ;
60525   }
60526   {
60527     try {
60528       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
60529     } catch (std::out_of_range& e) {
60530       {
60531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60532       };
60533     } catch (std::exception& e) {
60534       {
60535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60536       };
60537     } catch (Dali::DaliException e) {
60538       {
60539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60540       };
60541     } catch (...) {
60542       {
60543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60544       };
60545     }
60546   }
60547
60548 }
60549
60550
60551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
60552   void * jresult ;
60553   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
60554   Dali::Vector4 result;
60555
60556   arg1 = (Dali::Handle *)jarg1;
60557   {
60558     try {
60559       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
60560       if (resultMap)
60561       {
60562         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
60563         if(type && type->Get<int>() == Visual::COLOR )
60564         {
60565           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
60566           if (value)
60567           {
60568             result = value->Get<Vector4>();
60569           }
60570         }
60571       }
60572     } catch (std::out_of_range& e) {
60573       {
60574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60575       };
60576     } catch (std::exception& e) {
60577       {
60578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60579       };
60580     } catch (Dali::DaliException e) {
60581       {
60582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60583       };
60584     } catch (...) {
60585       {
60586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60587       };
60588     }
60589   }
60590
60591   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
60592   return jresult;
60593 }
60594
60595
60596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
60597   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60598   Dali::Property::Map *arg2 = 0 ;
60599
60600   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60601   arg2 = (Dali::Property::Map *)jarg2;
60602   if (!arg2) {
60603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
60604     return ;
60605   }
60606   {
60607     try {
60608       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
60609     } catch (std::out_of_range& e) {
60610       {
60611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60612       };
60613     } catch (std::exception& e) {
60614       {
60615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60616       };
60617     } catch (Dali::DaliException e) {
60618       {
60619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60620       };
60621     } catch (...) {
60622       {
60623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60624       };
60625     }
60626   }
60627
60628 }
60629
60630
60631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
60632   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60633
60634   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60635   {
60636     try {
60637       (arg1)->ClearBackground();
60638     } catch (std::out_of_range& e) {
60639       {
60640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60641       };
60642     } catch (std::exception& e) {
60643       {
60644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60645       };
60646     } catch (Dali::DaliException e) {
60647       {
60648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60649       };
60650     } catch (...) {
60651       {
60652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60653       };
60654     }
60655   }
60656
60657 }
60658
60659
60660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
60661   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60662   Dali::Gesture::Type arg2 ;
60663
60664   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60665   arg2 = (Dali::Gesture::Type)jarg2;
60666   {
60667     try {
60668       (arg1)->EnableGestureDetection(arg2);
60669     } catch (std::out_of_range& e) {
60670       {
60671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60672       };
60673     } catch (std::exception& e) {
60674       {
60675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60676       };
60677     } catch (Dali::DaliException e) {
60678       {
60679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60680       };
60681     } catch (...) {
60682       {
60683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60684       };
60685     }
60686   }
60687
60688 }
60689
60690
60691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
60692   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60693   Dali::Gesture::Type arg2 ;
60694
60695   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60696   arg2 = (Dali::Gesture::Type)jarg2;
60697   {
60698     try {
60699       (arg1)->DisableGestureDetection(arg2);
60700     } catch (std::out_of_range& e) {
60701       {
60702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60703       };
60704     } catch (std::exception& e) {
60705       {
60706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60707       };
60708     } catch (Dali::DaliException e) {
60709       {
60710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60711       };
60712     } catch (...) {
60713       {
60714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60715       };
60716     }
60717   }
60718
60719 }
60720
60721
60722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
60723   void * jresult ;
60724   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60725   Dali::PinchGestureDetector result;
60726
60727   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60728   {
60729     try {
60730       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
60731     } catch (std::out_of_range& e) {
60732       {
60733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60734       };
60735     } catch (std::exception& e) {
60736       {
60737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60738       };
60739     } catch (Dali::DaliException e) {
60740       {
60741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60742       };
60743     } catch (...) {
60744       {
60745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60746       };
60747     }
60748   }
60749
60750   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
60751   return jresult;
60752 }
60753
60754
60755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
60756   void * jresult ;
60757   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60758   Dali::PanGestureDetector result;
60759
60760   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60761   {
60762     try {
60763       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
60764     } catch (std::out_of_range& e) {
60765       {
60766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60767       };
60768     } catch (std::exception& e) {
60769       {
60770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60771       };
60772     } catch (Dali::DaliException e) {
60773       {
60774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60775       };
60776     } catch (...) {
60777       {
60778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60779       };
60780     }
60781   }
60782
60783   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
60784   return jresult;
60785 }
60786
60787
60788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
60789   void * jresult ;
60790   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60791   Dali::TapGestureDetector result;
60792
60793   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60794   {
60795     try {
60796       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
60797     } catch (std::out_of_range& e) {
60798       {
60799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60800       };
60801     } catch (std::exception& e) {
60802       {
60803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60804       };
60805     } catch (Dali::DaliException e) {
60806       {
60807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60808       };
60809     } catch (...) {
60810       {
60811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60812       };
60813     }
60814   }
60815
60816   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
60817   return jresult;
60818 }
60819
60820
60821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
60822   void * jresult ;
60823   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60824   Dali::LongPressGestureDetector result;
60825
60826   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60827   {
60828     try {
60829       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
60830     } catch (std::out_of_range& e) {
60831       {
60832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60833       };
60834     } catch (std::exception& e) {
60835       {
60836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60837       };
60838     } catch (Dali::DaliException e) {
60839       {
60840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60841       };
60842     } catch (...) {
60843       {
60844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60845       };
60846     }
60847   }
60848
60849   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
60850   return jresult;
60851 }
60852
60853
60854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
60855   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60856   bool arg2 ;
60857
60858   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60859   arg2 = jarg2 ? true : false;
60860   {
60861     try {
60862       (arg1)->SetKeyboardNavigationSupport(arg2);
60863     } catch (std::out_of_range& e) {
60864       {
60865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60866       };
60867     } catch (std::exception& e) {
60868       {
60869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60870       };
60871     } catch (Dali::DaliException e) {
60872       {
60873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60874       };
60875     } catch (...) {
60876       {
60877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60878       };
60879     }
60880   }
60881
60882 }
60883
60884
60885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
60886   unsigned int jresult ;
60887   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60888   bool result;
60889
60890   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60891   {
60892     try {
60893       result = (bool)(arg1)->IsKeyboardNavigationSupported();
60894     } catch (std::out_of_range& e) {
60895       {
60896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60897       };
60898     } catch (std::exception& e) {
60899       {
60900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60901       };
60902     } catch (Dali::DaliException e) {
60903       {
60904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60905       };
60906     } catch (...) {
60907       {
60908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60909       };
60910     }
60911   }
60912
60913   jresult = result;
60914   return jresult;
60915 }
60916
60917
60918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
60919   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60920
60921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60922   {
60923     try {
60924       (arg1)->SetKeyInputFocus();
60925     } catch (std::out_of_range& e) {
60926       {
60927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60928       };
60929     } catch (std::exception& e) {
60930       {
60931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60932       };
60933     } catch (Dali::DaliException e) {
60934       {
60935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60936       };
60937     } catch (...) {
60938       {
60939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60940       };
60941     }
60942   }
60943
60944 }
60945
60946
60947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
60948   unsigned int jresult ;
60949   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60950   bool result;
60951
60952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60953   {
60954     try {
60955       result = (bool)(arg1)->HasKeyInputFocus();
60956     } catch (std::out_of_range& e) {
60957       {
60958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60959       };
60960     } catch (std::exception& e) {
60961       {
60962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60963       };
60964     } catch (Dali::DaliException e) {
60965       {
60966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60967       };
60968     } catch (...) {
60969       {
60970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60971       };
60972     }
60973   }
60974
60975   jresult = result;
60976   return jresult;
60977 }
60978
60979
60980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
60981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60982
60983   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60984   {
60985     try {
60986       (arg1)->ClearKeyInputFocus();
60987     } catch (std::out_of_range& e) {
60988       {
60989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60990       };
60991     } catch (std::exception& e) {
60992       {
60993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60994       };
60995     } catch (Dali::DaliException e) {
60996       {
60997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60998       };
60999     } catch (...) {
61000       {
61001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61002       };
61003     }
61004   }
61005
61006 }
61007
61008
61009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
61010   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61011   bool arg2 ;
61012
61013   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61014   arg2 = jarg2 ? true : false;
61015   {
61016     try {
61017       (arg1)->SetAsKeyboardFocusGroup(arg2);
61018     } catch (std::out_of_range& e) {
61019       {
61020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61021       };
61022     } catch (std::exception& e) {
61023       {
61024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61025       };
61026     } catch (Dali::DaliException e) {
61027       {
61028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61029       };
61030     } catch (...) {
61031       {
61032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61033       };
61034     }
61035   }
61036
61037 }
61038
61039
61040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
61041   unsigned int jresult ;
61042   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61043   bool result;
61044
61045   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61046   {
61047     try {
61048       result = (bool)(arg1)->IsKeyboardFocusGroup();
61049     } catch (std::out_of_range& e) {
61050       {
61051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61052       };
61053     } catch (std::exception& e) {
61054       {
61055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61056       };
61057     } catch (Dali::DaliException e) {
61058       {
61059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61060       };
61061     } catch (...) {
61062       {
61063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61064       };
61065     }
61066   }
61067
61068   jresult = result;
61069   return jresult;
61070 }
61071
61072
61073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
61074   void * jresult ;
61075   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61076   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
61077
61078   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61079   {
61080     try {
61081       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
61082     } catch (std::out_of_range& e) {
61083       {
61084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61085       };
61086     } catch (std::exception& e) {
61087       {
61088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61089       };
61090     } catch (Dali::DaliException e) {
61091       {
61092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61093       };
61094     } catch (...) {
61095       {
61096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61097       };
61098     }
61099   }
61100
61101   jresult = (void *)result;
61102   return jresult;
61103 }
61104
61105
61106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
61107   void * jresult ;
61108   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61109   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
61110
61111   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61112   {
61113     try {
61114       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
61115     } catch (std::out_of_range& e) {
61116       {
61117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61118       };
61119     } catch (std::exception& e) {
61120       {
61121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61122       };
61123     } catch (Dali::DaliException e) {
61124       {
61125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61126       };
61127     } catch (...) {
61128       {
61129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61130       };
61131     }
61132   }
61133
61134   jresult = (void *)result;
61135   return jresult;
61136 }
61137
61138
61139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
61140   void * jresult ;
61141   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61142   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
61143
61144   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61145   {
61146     try {
61147       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
61148     } catch (std::out_of_range& e) {
61149       {
61150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61151       };
61152     } catch (std::exception& e) {
61153       {
61154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61155       };
61156     } catch (Dali::DaliException e) {
61157       {
61158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61159       };
61160     } catch (...) {
61161       {
61162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61163       };
61164     }
61165   }
61166
61167   jresult = (void *)result;
61168   return jresult;
61169 }
61170
61171
61172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
61173   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61174   int arg2 ;
61175   SwigDirector_ViewImpl *darg = 0;
61176
61177   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61178   arg2 = (int)jarg2;
61179   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61180   if(!darg) {
61181     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61182     return;
61183   }
61184   {
61185     try {
61186       if(darg) {
61187         (darg)->OnStageConnection(arg2);
61188       }
61189     } catch (std::out_of_range& e) {
61190       {
61191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61192       };
61193     } catch (std::exception& e) {
61194       {
61195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61196       };
61197     } catch (Dali::DaliException e) {
61198       {
61199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61200       };
61201     } catch (...) {
61202       {
61203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61204       };
61205     }
61206   }
61207
61208 }
61209
61210
61211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
61212   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61213   int arg2 ;
61214   SwigDirector_ViewImpl *darg = 0;
61215
61216   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61217   arg2 = (int)jarg2;
61218   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61219   if(!darg) {
61220     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61221     return;
61222   }
61223   {
61224     try {
61225       if(darg) {
61226         (darg)->OnStageConnectionSwigPublic(arg2);
61227       }
61228     } catch (std::out_of_range& e) {
61229       {
61230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61231       };
61232     } catch (std::exception& e) {
61233       {
61234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61235       };
61236     } catch (Dali::DaliException e) {
61237       {
61238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61239       };
61240     } catch (...) {
61241       {
61242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61243       };
61244     }
61245   }
61246
61247 }
61248
61249
61250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
61251   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61252   SwigDirector_ViewImpl *darg = 0;
61253
61254   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61255   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61256   if(!darg) {
61257     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61258     return;
61259   }
61260   {
61261     try {
61262       if(darg) {
61263         (darg)->OnStageDisconnection();
61264       }
61265     } catch (std::out_of_range& e) {
61266       {
61267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61268       };
61269     } catch (std::exception& e) {
61270       {
61271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61272       };
61273     } catch (Dali::DaliException e) {
61274       {
61275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61276       };
61277     } catch (...) {
61278       {
61279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61280       };
61281     }
61282   }
61283
61284 }
61285
61286
61287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
61288   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61289   SwigDirector_ViewImpl *darg = 0;
61290
61291   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61292   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61293   if(!darg) {
61294     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61295     return;
61296   }
61297   {
61298     try {
61299       if(darg) {
61300         (darg)->OnStageDisconnectionSwigPublic();
61301       }
61302     } catch (std::out_of_range& e) {
61303       {
61304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61305       };
61306     } catch (std::exception& e) {
61307       {
61308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61309       };
61310     } catch (Dali::DaliException e) {
61311       {
61312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61313       };
61314     } catch (...) {
61315       {
61316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61317       };
61318     }
61319   }
61320
61321 }
61322
61323
61324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
61325   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61326   Dali::Actor *arg2 = 0 ;
61327   SwigDirector_ViewImpl *darg = 0;
61328
61329   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61330   arg2 = (Dali::Actor *)jarg2;
61331   if (!arg2) {
61332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61333     return ;
61334   }
61335   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61336   if(!darg) {
61337     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61338     return;
61339   }
61340   {
61341     try {
61342       if(darg) {
61343         (darg)->OnChildAdd(*arg2);
61344       }
61345     } catch (std::out_of_range& e) {
61346       {
61347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61348       };
61349     } catch (std::exception& e) {
61350       {
61351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61352       };
61353     } catch (Dali::DaliException e) {
61354       {
61355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61356       };
61357     } catch (...) {
61358       {
61359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61360       };
61361     }
61362   }
61363
61364 }
61365
61366
61367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61368   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61369   Dali::Actor *arg2 = 0 ;
61370   SwigDirector_ViewImpl *darg = 0;
61371
61372   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61373   arg2 = (Dali::Actor *)jarg2;
61374   if (!arg2) {
61375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61376     return ;
61377   }
61378   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61379   if(!darg) {
61380     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61381     return;
61382   }
61383   {
61384     try {
61385       if(darg) {
61386           (darg)->OnChildAddSwigPublic(*arg2);
61387       }
61388     } catch (std::out_of_range& e) {
61389       {
61390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61391       };
61392     } catch (std::exception& e) {
61393       {
61394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61395       };
61396     } catch (Dali::DaliException e) {
61397       {
61398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61399       };
61400     } catch (...) {
61401       {
61402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61403       };
61404     }
61405   }
61406
61407 }
61408
61409
61410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
61411   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61412   Dali::Actor *arg2 = 0 ;
61413   SwigDirector_ViewImpl *darg = 0;
61414
61415   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61416   arg2 = (Dali::Actor *)jarg2;
61417   if (!arg2) {
61418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61419     return ;
61420   }
61421   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61422   if(!darg) {
61423     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61424     return;
61425   }
61426   {
61427     try {
61428       if(darg) {
61429         (darg)->OnChildRemove(*arg2);
61430       }
61431     } catch (std::out_of_range& e) {
61432       {
61433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61434       };
61435     } catch (std::exception& e) {
61436       {
61437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61438       };
61439     } catch (Dali::DaliException e) {
61440       {
61441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61442       };
61443     } catch (...) {
61444       {
61445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61446       };
61447     }
61448   }
61449
61450 }
61451
61452
61453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61454   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61455   Dali::Actor *arg2 = 0 ;
61456   SwigDirector_ViewImpl *darg = 0;
61457
61458   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61459   arg2 = (Dali::Actor *)jarg2;
61460   if (!arg2) {
61461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61462     return ;
61463   }
61464   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61465   if(!darg) {
61466     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61467     return;
61468   }
61469   {
61470     try {
61471       if(darg) {
61472         (darg)->OnChildRemoveSwigPublic(*arg2);
61473       }
61474     } catch (std::out_of_range& e) {
61475       {
61476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61477       };
61478     } catch (std::exception& e) {
61479       {
61480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61481       };
61482     } catch (Dali::DaliException e) {
61483       {
61484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61485       };
61486     } catch (...) {
61487       {
61488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61489       };
61490     }
61491   }
61492
61493 }
61494
61495
61496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
61497   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61498   Dali::Property::Index arg2 ;
61499   Dali::Property::Value arg3 ;
61500   Dali::Property::Value *argp3 ;
61501   SwigDirector_ViewImpl *darg = 0;
61502
61503   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61504   arg2 = (Dali::Property::Index)jarg2;
61505   argp3 = (Dali::Property::Value *)jarg3;
61506   if (!argp3) {
61507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
61508     return ;
61509   }
61510   arg3 = *argp3;
61511   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61512   if (!darg) {
61513     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61514     return;
61515   }
61516   {
61517     try {
61518       (darg)->OnPropertySet(arg2,arg3);
61519     } catch (std::out_of_range& e) {
61520       {
61521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61522       };
61523     } catch (std::exception& e) {
61524       {
61525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61526       };
61527     } catch (Dali::DaliException e) {
61528       {
61529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61530       };
61531     } catch (...) {
61532       {
61533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61534       };
61535     }
61536   }
61537
61538 }
61539
61540
61541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
61542   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61543   Dali::Property::Index arg2 ;
61544   Dali::Property::Value arg3 ;
61545   Dali::Property::Value *argp3 ;
61546   SwigDirector_ViewImpl *darg = 0;
61547
61548   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61549   arg2 = (Dali::Property::Index)jarg2;
61550   argp3 = (Dali::Property::Value *)jarg3;
61551   if (!argp3) {
61552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
61553     return ;
61554   }
61555   arg3 = *argp3;
61556   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61557   if (!darg) {
61558     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61559     return;
61560   }
61561   {
61562     try {
61563       (darg)->OnPropertySetSwigPublic(arg2,arg3);
61564     } catch (std::out_of_range& e) {
61565       {
61566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61567       };
61568     } catch (std::exception& e) {
61569       {
61570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61571       };
61572     } catch (Dali::DaliException e) {
61573       {
61574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61575       };
61576     } catch (...) {
61577       {
61578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61579       };
61580     }
61581   }
61582
61583 }
61584
61585
61586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
61587   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61588   Dali::Vector3 *arg2 = 0 ;
61589   SwigDirector_ViewImpl *darg = 0;
61590
61591   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61592   arg2 = (Dali::Vector3 *)jarg2;
61593   if (!arg2) {
61594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61595     return ;
61596   }
61597   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61598   if (!darg) {
61599     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61600     return;
61601   }
61602   {
61603     try {
61604       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
61605     } catch (std::out_of_range& e) {
61606       {
61607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61608       };
61609     } catch (std::exception& e) {
61610       {
61611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61612       };
61613     } catch (Dali::DaliException e) {
61614       {
61615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61616       };
61617     } catch (...) {
61618       {
61619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61620       };
61621     }
61622   }
61623
61624 }
61625
61626
61627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61628   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61629   Dali::Vector3 *arg2 = 0 ;
61630   SwigDirector_ViewImpl *darg = 0;
61631
61632   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61633   arg2 = (Dali::Vector3 *)jarg2;
61634   if (!arg2) {
61635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61636     return ;
61637   }
61638   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61639   if (!darg) {
61640     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61641     return;
61642   }
61643   {
61644     try {
61645       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
61646     } catch (std::out_of_range& e) {
61647       {
61648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61649       };
61650     } catch (std::exception& e) {
61651       {
61652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61653       };
61654     } catch (Dali::DaliException e) {
61655       {
61656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61657       };
61658     } catch (...) {
61659       {
61660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61661       };
61662     }
61663   }
61664
61665 }
61666
61667
61668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
61669   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61670   Dali::Animation *arg2 = 0 ;
61671   Dali::Vector3 *arg3 = 0 ;
61672   SwigDirector_ViewImpl *darg = 0;
61673
61674   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61675   arg2 = (Dali::Animation *)jarg2;
61676   if (!arg2) {
61677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61678     return ;
61679   }
61680   arg3 = (Dali::Vector3 *)jarg3;
61681   if (!arg3) {
61682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61683     return ;
61684   }
61685   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61686   if (!darg) {
61687     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61688     return;
61689   }
61690   {
61691     try {
61692       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
61693     } catch (std::out_of_range& e) {
61694       {
61695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61696       };
61697     } catch (std::exception& e) {
61698       {
61699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61700       };
61701     } catch (Dali::DaliException e) {
61702       {
61703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61704       };
61705     } catch (...) {
61706       {
61707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61708       };
61709     }
61710   }
61711
61712 }
61713
61714
61715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61716   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61717   Dali::Animation *arg2 = 0 ;
61718   Dali::Vector3 *arg3 = 0 ;
61719   SwigDirector_ViewImpl *darg = 0;
61720
61721   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61722   arg2 = (Dali::Animation *)jarg2;
61723   if (!arg2) {
61724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61725     return ;
61726   }
61727   arg3 = (Dali::Vector3 *)jarg3;
61728   if (!arg3) {
61729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61730     return ;
61731   }
61732   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61733   if (!darg) {
61734     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61735     return;
61736   }
61737   {
61738     try {
61739       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
61740     } catch (std::out_of_range& e) {
61741       {
61742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61743       };
61744     } catch (std::exception& e) {
61745       {
61746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61747       };
61748     } catch (Dali::DaliException e) {
61749       {
61750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61751       };
61752     } catch (...) {
61753       {
61754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61755       };
61756     }
61757   }
61758
61759 }
61760
61761
61762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
61763   unsigned int jresult ;
61764   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61765   Dali::TouchEvent *arg2 = 0 ;
61766   SwigDirector_ViewImpl *darg = 0;
61767   bool result;
61768
61769   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61770   arg2 = (Dali::TouchEvent *)jarg2;
61771   if (!arg2) {
61772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61773     return 0;
61774   }
61775   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61776   if (!darg) {
61777     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61778     return 0;
61779   }
61780   {
61781     try {
61782       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
61783     } catch (std::out_of_range& e) {
61784       {
61785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61786       };
61787     } catch (std::exception& e) {
61788       {
61789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61790       };
61791     } catch (Dali::DaliException e) {
61792       {
61793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61794       };
61795     } catch (...) {
61796       {
61797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61798       };
61799     }
61800   }
61801
61802   jresult = result;
61803   return jresult;
61804 }
61805
61806
61807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61808   unsigned int jresult ;
61809   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61810   Dali::TouchEvent *arg2 = 0 ;
61811   SwigDirector_ViewImpl *darg = 0;
61812   bool result;
61813
61814   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61815   arg2 = (Dali::TouchEvent *)jarg2;
61816   if (!arg2) {
61817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61818     return 0;
61819   }
61820   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61821   if (!darg) {
61822     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61823     return 0;
61824   }
61825   {
61826     try {
61827       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
61828     } catch (std::out_of_range& e) {
61829       {
61830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61831       };
61832     } catch (std::exception& e) {
61833       {
61834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61835       };
61836     } catch (Dali::DaliException e) {
61837       {
61838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61839       };
61840     } catch (...) {
61841       {
61842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61843       };
61844     }
61845   }
61846
61847   jresult = result;
61848   return jresult;
61849 }
61850
61851
61852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
61853   unsigned int jresult ;
61854   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61855   Dali::HoverEvent *arg2 = 0 ;
61856   SwigDirector_ViewImpl *darg = 0;
61857   bool result;
61858
61859   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61860   arg2 = (Dali::HoverEvent *)jarg2;
61861   if (!arg2) {
61862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61863     return 0;
61864   }
61865   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61866   if (!darg) {
61867     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61868     return 0;
61869   }
61870   {
61871     try {
61872       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
61873     } catch (std::out_of_range& e) {
61874       {
61875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61876       };
61877     } catch (std::exception& e) {
61878       {
61879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61880       };
61881     } catch (Dali::DaliException e) {
61882       {
61883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61884       };
61885     } catch (...) {
61886       {
61887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61888       };
61889     }
61890   }
61891
61892   jresult = result;
61893   return jresult;
61894 }
61895
61896
61897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61898   unsigned int jresult ;
61899   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61900   Dali::HoverEvent *arg2 = 0 ;
61901   SwigDirector_ViewImpl *darg = 0;
61902   bool result;
61903
61904   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61905   arg2 = (Dali::HoverEvent *)jarg2;
61906   if (!arg2) {
61907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61908     return 0;
61909   }
61910   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61911   if (!darg) {
61912     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61913     return 0;
61914   }
61915   {
61916     try {
61917       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
61918     } catch (std::out_of_range& e) {
61919       {
61920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61921       };
61922     } catch (std::exception& e) {
61923       {
61924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61925       };
61926     } catch (Dali::DaliException e) {
61927       {
61928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61929       };
61930     } catch (...) {
61931       {
61932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61933       };
61934     }
61935   }
61936
61937   jresult = result;
61938   return jresult;
61939 }
61940
61941
61942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
61943   unsigned int jresult ;
61944   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61945   Dali::KeyEvent *arg2 = 0 ;
61946   SwigDirector_ViewImpl *darg = 0;
61947   bool result;
61948
61949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61950   arg2 = (Dali::KeyEvent *)jarg2;
61951   if (!arg2) {
61952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61953     return 0;
61954   }
61955   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61956   if (!darg) {
61957     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61958     return 0;
61959   }
61960   {
61961     try {
61962       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
61963     } catch (std::out_of_range& e) {
61964       {
61965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61966       };
61967     } catch (std::exception& e) {
61968       {
61969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61970       };
61971     } catch (Dali::DaliException e) {
61972       {
61973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61974       };
61975     } catch (...) {
61976       {
61977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61978       };
61979     }
61980   }
61981
61982   jresult = result;
61983   return jresult;
61984 }
61985
61986
61987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61988   unsigned int jresult ;
61989   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61990   Dali::KeyEvent *arg2 = 0 ;
61991   SwigDirector_ViewImpl *darg = 0;
61992   bool result;
61993
61994   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61995   arg2 = (Dali::KeyEvent *)jarg2;
61996   if (!arg2) {
61997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61998     return 0;
61999   }
62000   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62001   if (!darg) {
62002     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62003     return 0;
62004   }
62005   {
62006     try {
62007       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
62008     } catch (std::out_of_range& e) {
62009       {
62010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62011       };
62012     } catch (std::exception& e) {
62013       {
62014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62015       };
62016     } catch (Dali::DaliException e) {
62017       {
62018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62019       };
62020     } catch (...) {
62021       {
62022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62023       };
62024     }
62025   }
62026
62027   jresult = result;
62028   return jresult;
62029 }
62030
62031
62032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
62033   unsigned int jresult ;
62034   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62035   Dali::WheelEvent *arg2 = 0 ;
62036   SwigDirector_ViewImpl *darg = 0;
62037   bool result;
62038
62039   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62040   arg2 = (Dali::WheelEvent *)jarg2;
62041   if (!arg2) {
62042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
62043     return 0;
62044   }
62045   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62046   if (!darg) {
62047     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62048     return 0;
62049   }
62050   {
62051     try {
62052       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
62053     } catch (std::out_of_range& e) {
62054       {
62055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62056       };
62057     } catch (std::exception& e) {
62058       {
62059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62060       };
62061     } catch (Dali::DaliException e) {
62062       {
62063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62064       };
62065     } catch (...) {
62066       {
62067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62068       };
62069     }
62070   }
62071
62072   jresult = result;
62073   return jresult;
62074 }
62075
62076
62077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62078   unsigned int jresult ;
62079   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62080   Dali::WheelEvent *arg2 = 0 ;
62081   SwigDirector_ViewImpl *darg = 0;
62082   bool result;
62083
62084   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62085   arg2 = (Dali::WheelEvent *)jarg2;
62086   if (!arg2) {
62087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
62088     return 0;
62089   }
62090   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62091   if (!darg) {
62092     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62093     return 0;
62094   }
62095   {
62096     try {
62097       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
62098     } catch (std::out_of_range& e) {
62099       {
62100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62101       };
62102     } catch (std::exception& e) {
62103       {
62104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62105       };
62106     } catch (Dali::DaliException e) {
62107       {
62108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62109       };
62110     } catch (...) {
62111       {
62112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62113       };
62114     }
62115   }
62116
62117   jresult = result;
62118   return jresult;
62119 }
62120
62121
62122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
62123   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62124   Dali::Vector2 *arg2 = 0 ;
62125   Dali::RelayoutContainer *arg3 = 0 ;
62126   SwigDirector_ViewImpl *darg = 0;
62127
62128   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62129   arg2 = (Dali::Vector2 *)jarg2;
62130   if (!arg2) {
62131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
62132     return ;
62133   }
62134   arg3 = (Dali::RelayoutContainer *)jarg3;
62135   if (!arg3) {
62136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
62137     return ;
62138   }
62139   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62140   if (!darg) {
62141     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62142     return;
62143   }
62144   {
62145     try {
62146       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
62147     } catch (std::out_of_range& e) {
62148       {
62149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62150       };
62151     } catch (std::exception& e) {
62152       {
62153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62154       };
62155     } catch (Dali::DaliException e) {
62156       {
62157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62158       };
62159     } catch (...) {
62160       {
62161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62162       };
62163     }
62164   }
62165
62166 }
62167
62168
62169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62170   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62171   Dali::Vector2 *arg2 = 0 ;
62172   Dali::RelayoutContainer *arg3 = 0 ;
62173   SwigDirector_ViewImpl *darg = 0;
62174
62175   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62176   arg2 = (Dali::Vector2 *)jarg2;
62177   if (!arg2) {
62178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
62179     return ;
62180   }
62181   arg3 = (Dali::RelayoutContainer *)jarg3;
62182   if (!arg3) {
62183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
62184     return ;
62185   }
62186   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62187   if (!darg) {
62188     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62189     return;
62190   }
62191   {
62192     try {
62193       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
62194     } catch (std::out_of_range& e) {
62195       {
62196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62197       };
62198     } catch (std::exception& e) {
62199       {
62200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62201       };
62202     } catch (Dali::DaliException e) {
62203       {
62204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62205       };
62206     } catch (...) {
62207       {
62208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62209       };
62210     }
62211   }
62212
62213 }
62214
62215
62216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
62217   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62218   Dali::ResizePolicy::Type arg2 ;
62219   Dali::Dimension::Type arg3 ;
62220   SwigDirector_ViewImpl *darg = 0;
62221
62222   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62223   arg2 = (Dali::ResizePolicy::Type)jarg2;
62224   arg3 = (Dali::Dimension::Type)jarg3;
62225   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62226   if (!darg) {
62227     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62228     return;
62229   }
62230   {
62231     try {
62232       (darg)->OnSetResizePolicy(arg2,arg3);
62233     } catch (std::out_of_range& e) {
62234       {
62235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62236       };
62237     } catch (std::exception& e) {
62238       {
62239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62240       };
62241     } catch (Dali::DaliException e) {
62242       {
62243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62244       };
62245     } catch (...) {
62246       {
62247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62248       };
62249     }
62250   }
62251
62252 }
62253
62254
62255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
62256   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62257   Dali::ResizePolicy::Type arg2 ;
62258   Dali::Dimension::Type arg3 ;
62259   SwigDirector_ViewImpl *darg = 0;
62260
62261   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62262   arg2 = (Dali::ResizePolicy::Type)jarg2;
62263   arg3 = (Dali::Dimension::Type)jarg3;
62264   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62265   if (!darg) {
62266     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62267     return;
62268   }
62269   {
62270     try {
62271       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
62272     } catch (std::out_of_range& e) {
62273       {
62274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62275       };
62276     } catch (std::exception& e) {
62277       {
62278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62279       };
62280     } catch (Dali::DaliException e) {
62281       {
62282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62283       };
62284     } catch (...) {
62285       {
62286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62287       };
62288     }
62289   }
62290
62291 }
62292
62293
62294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
62295   void * jresult ;
62296   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62297   SwigDirector_ViewImpl *darg = 0;
62298   Dali::Vector3 result;
62299
62300   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62301   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62302   if (!darg) {
62303     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62304     return 0;
62305   }
62306   {
62307     try {
62308       result = (darg)->GetNaturalSize();
62309     } catch (std::out_of_range& e) {
62310       {
62311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62312       };
62313     } catch (std::exception& e) {
62314       {
62315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62316       };
62317     } catch (Dali::DaliException e) {
62318       {
62319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62320       };
62321     } catch (...) {
62322       {
62323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62324       };
62325     }
62326   }
62327
62328   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
62329   return jresult;
62330 }
62331
62332
62333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
62334   void * jresult ;
62335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62336   SwigDirector_ViewImpl *darg = 0;
62337   Dali::Vector3 result;
62338
62339   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62340   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62341   if (!darg) {
62342     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62343     return 0;
62344   }
62345   {
62346     try {
62347       result = (darg)->GetNaturalSizeSwigPublic();
62348     } catch (std::out_of_range& e) {
62349       {
62350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62351       };
62352     } catch (std::exception& e) {
62353       {
62354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62355       };
62356     } catch (Dali::DaliException e) {
62357       {
62358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62359       };
62360     } catch (...) {
62361       {
62362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62363       };
62364     }
62365   }
62366
62367   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
62368   return jresult;
62369 }
62370
62371
62372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
62373   float jresult ;
62374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62375   Dali::Actor *arg2 = 0 ;
62376   Dali::Dimension::Type arg3 ;
62377   SwigDirector_ViewImpl *darg = 0;
62378   float result;
62379
62380   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62381   arg2 = (Dali::Actor *)jarg2;
62382   if (!arg2) {
62383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
62384     return 0;
62385   }
62386   arg3 = (Dali::Dimension::Type)jarg3;
62387   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62388   if (!darg) {
62389     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62390     return 0;
62391   }
62392   {
62393     try {
62394       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
62395     } catch (std::out_of_range& e) {
62396       {
62397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62398       };
62399     } catch (std::exception& e) {
62400       {
62401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62402       };
62403     } catch (Dali::DaliException e) {
62404       {
62405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62406       };
62407     } catch (...) {
62408       {
62409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62410       };
62411     }
62412   }
62413
62414   jresult = result;
62415   return jresult;
62416 }
62417
62418
62419 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
62420   float jresult ;
62421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62422   Dali::Actor *arg2 = 0 ;
62423   Dali::Dimension::Type arg3 ;
62424   SwigDirector_ViewImpl *darg = 0;
62425   float result;
62426
62427   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62428   arg2 = (Dali::Actor *)jarg2;
62429   if (!arg2) {
62430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
62431     return 0;
62432   }
62433   arg3 = (Dali::Dimension::Type)jarg3;
62434   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62435   if (!darg) {
62436     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62437     return 0;
62438   }
62439   {
62440     try {
62441       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
62442     } catch (std::out_of_range& e) {
62443       {
62444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62445       };
62446     } catch (std::exception& e) {
62447       {
62448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62449       };
62450     } catch (Dali::DaliException e) {
62451       {
62452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62453       };
62454     } catch (...) {
62455       {
62456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62457       };
62458     }
62459   }
62460
62461   jresult = result;
62462   return jresult;
62463 }
62464
62465
62466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
62467   float jresult ;
62468   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62469   float arg2 ;
62470   SwigDirector_ViewImpl *darg = 0;
62471   float result;
62472
62473   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62474   arg2 = (float)jarg2;
62475   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62476   if (!darg) {
62477     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62478     return 0;
62479   }
62480   {
62481     try {
62482       result = (float)(darg)->GetHeightForWidth(arg2);
62483     } catch (std::out_of_range& e) {
62484       {
62485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62486       };
62487     } catch (std::exception& e) {
62488       {
62489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62490       };
62491     } catch (Dali::DaliException e) {
62492       {
62493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62494       };
62495     } catch (...) {
62496       {
62497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62498       };
62499     }
62500   }
62501
62502   jresult = result;
62503   return jresult;
62504 }
62505
62506
62507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
62508   float jresult ;
62509   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62510   float arg2 ;
62511   SwigDirector_ViewImpl *darg = 0;
62512   float result;
62513
62514   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62515   arg2 = (float)jarg2;
62516   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62517   if (!darg) {
62518     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62519     return 0;
62520   }
62521   {
62522     try {
62523       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
62524     } catch (std::out_of_range& e) {
62525       {
62526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62527       };
62528     } catch (std::exception& e) {
62529       {
62530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62531       };
62532     } catch (Dali::DaliException e) {
62533       {
62534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62535       };
62536     } catch (...) {
62537       {
62538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62539       };
62540     }
62541   }
62542
62543   jresult = result;
62544   return jresult;
62545 }
62546
62547
62548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
62549   float jresult ;
62550   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62551   float arg2 ;
62552   SwigDirector_ViewImpl *darg = 0;
62553   float result;
62554
62555   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62556   arg2 = (float)jarg2;
62557   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62558   if (!darg) {
62559     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62560     return 0;
62561   }
62562   {
62563     try {
62564       result = (float)(darg)->GetWidthForHeight(arg2);
62565     } catch (std::out_of_range& e) {
62566       {
62567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62568       };
62569     } catch (std::exception& e) {
62570       {
62571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62572       };
62573     } catch (Dali::DaliException e) {
62574       {
62575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62576       };
62577     } catch (...) {
62578       {
62579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62580       };
62581     }
62582   }
62583
62584   jresult = result;
62585   return jresult;
62586 }
62587
62588
62589 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
62590   float jresult ;
62591   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62592   float arg2 ;
62593   SwigDirector_ViewImpl *darg = 0;
62594   float result;
62595
62596   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62597   arg2 = (float)jarg2;
62598   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62599   if (!darg) {
62600     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62601     return 0;
62602   }
62603   {
62604     try {
62605       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
62606     } catch (std::out_of_range& e) {
62607       {
62608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62609       };
62610     } catch (std::exception& e) {
62611       {
62612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62613       };
62614     } catch (Dali::DaliException e) {
62615       {
62616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62617       };
62618     } catch (...) {
62619       {
62620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62621       };
62622     }
62623   }
62624
62625   jresult = result;
62626   return jresult;
62627 }
62628
62629
62630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
62631   unsigned int jresult ;
62632   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62633   Dali::Dimension::Type arg2 ;
62634   SwigDirector_ViewImpl *darg = 0;
62635   bool result;
62636
62637   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62638   arg2 = (Dali::Dimension::Type)jarg2;
62639   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62640   if (!darg) {
62641     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62642     return 0;
62643   }
62644   {
62645     try {
62646       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
62647     } catch (std::out_of_range& e) {
62648       {
62649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62650       };
62651     } catch (std::exception& e) {
62652       {
62653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62654       };
62655     } catch (Dali::DaliException e) {
62656       {
62657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62658       };
62659     } catch (...) {
62660       {
62661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62662       };
62663     }
62664   }
62665
62666   jresult = result;
62667   return jresult;
62668 }
62669
62670
62671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
62672   unsigned int jresult ;
62673   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62674   Dali::Dimension::Type arg2 ;
62675   SwigDirector_ViewImpl *darg = 0;
62676   bool result;
62677
62678   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62679   arg2 = (Dali::Dimension::Type)jarg2;
62680   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62681   if (!darg) {
62682     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62683     return 0;
62684   }
62685   {
62686     try {
62687       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
62688     } catch (std::out_of_range& e) {
62689       {
62690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62691       };
62692     } catch (std::exception& e) {
62693       {
62694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62695       };
62696     } catch (Dali::DaliException e) {
62697       {
62698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62699       };
62700     } catch (...) {
62701       {
62702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62703       };
62704     }
62705   }
62706
62707   jresult = result;
62708   return jresult;
62709 }
62710
62711
62712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
62713   unsigned int jresult ;
62714   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62715   SwigDirector_ViewImpl *darg = 0;
62716   bool result;
62717
62718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62719   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62720   if (!darg) {
62721     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62722     return 0;
62723   }
62724   {
62725     try {
62726       result = (bool)(darg)->RelayoutDependentOnChildren();
62727     } catch (std::out_of_range& e) {
62728       {
62729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62730       };
62731     } catch (std::exception& e) {
62732       {
62733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62734       };
62735     } catch (Dali::DaliException e) {
62736       {
62737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62738       };
62739     } catch (...) {
62740       {
62741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62742       };
62743     }
62744   }
62745
62746   jresult = result;
62747   return jresult;
62748 }
62749
62750
62751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
62752   unsigned int jresult ;
62753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62754   SwigDirector_ViewImpl *darg = 0;
62755   bool result;
62756
62757   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62758   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62759   if (!darg) {
62760     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62761     return 0;
62762   }
62763   {
62764     try {
62765       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
62766     } catch (std::out_of_range& e) {
62767       {
62768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62769       };
62770     } catch (std::exception& e) {
62771       {
62772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62773       };
62774     } catch (Dali::DaliException e) {
62775       {
62776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62777       };
62778     } catch (...) {
62779       {
62780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62781       };
62782     }
62783   }
62784
62785   jresult = result;
62786   return jresult;
62787 }
62788
62789
62790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
62791   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62792   Dali::Dimension::Type arg2 ;
62793   SwigDirector_ViewImpl *darg = 0;
62794
62795   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62796   arg2 = (Dali::Dimension::Type)jarg2;
62797   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62798   if (!darg) {
62799     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62800     return;
62801   }
62802   {
62803     try {
62804       (darg)->OnCalculateRelayoutSize(arg2);
62805     } catch (std::out_of_range& e) {
62806       {
62807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62808       };
62809     } catch (std::exception& e) {
62810       {
62811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62812       };
62813     } catch (Dali::DaliException e) {
62814       {
62815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62816       };
62817     } catch (...) {
62818       {
62819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62820       };
62821     }
62822   }
62823
62824 }
62825
62826
62827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
62828   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62829   Dali::Dimension::Type arg2 ;
62830   SwigDirector_ViewImpl *darg = 0;
62831
62832   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62833   arg2 = (Dali::Dimension::Type)jarg2;
62834   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62835   if (!darg) {
62836     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62837     return;
62838   }
62839   {
62840     try {
62841       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
62842     } catch (std::out_of_range& e) {
62843       {
62844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62845       };
62846     } catch (std::exception& e) {
62847       {
62848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62849       };
62850     } catch (Dali::DaliException e) {
62851       {
62852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62853       };
62854     } catch (...) {
62855       {
62856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62857       };
62858     }
62859   }
62860
62861 }
62862
62863
62864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
62865   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62866   float arg2 ;
62867   Dali::Dimension::Type arg3 ;
62868   SwigDirector_ViewImpl *darg = 0;
62869
62870   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62871   arg2 = (float)jarg2;
62872   arg3 = (Dali::Dimension::Type)jarg3;
62873   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62874   if (!darg) {
62875     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62876     return;
62877   }
62878   {
62879     try {
62880       (darg)->OnLayoutNegotiated(arg2,arg3);
62881     } catch (std::out_of_range& e) {
62882       {
62883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62884       };
62885     } catch (std::exception& e) {
62886       {
62887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62888       };
62889     } catch (Dali::DaliException e) {
62890       {
62891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62892       };
62893     } catch (...) {
62894       {
62895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62896       };
62897     }
62898   }
62899
62900 }
62901
62902
62903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
62904   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62905   float arg2 ;
62906   Dali::Dimension::Type arg3 ;
62907   SwigDirector_ViewImpl *darg = 0;
62908
62909   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62910   arg2 = (float)jarg2;
62911   arg3 = (Dali::Dimension::Type)jarg3;
62912   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62913   if (!darg) {
62914     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62915     return;
62916   }
62917   {
62918     try {
62919       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
62920     } catch (std::out_of_range& e) {
62921       {
62922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62923       };
62924     } catch (std::exception& e) {
62925       {
62926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62927       };
62928     } catch (Dali::DaliException e) {
62929       {
62930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62931       };
62932     } catch (...) {
62933       {
62934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62935       };
62936     }
62937   }
62938
62939 }
62940
62941
62942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
62943   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62944
62945   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62946   {
62947     try {
62948       (arg1)->OnInitialize();
62949     } catch (std::out_of_range& e) {
62950       {
62951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62952       };
62953     } catch (std::exception& e) {
62954       {
62955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62956       };
62957     } catch (Dali::DaliException e) {
62958       {
62959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62960       };
62961     } catch (...) {
62962       {
62963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62964       };
62965     }
62966   }
62967
62968 }
62969
62970
62971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
62972   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62973
62974   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62975   {
62976     try {
62977       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
62978     } catch (std::out_of_range& e) {
62979       {
62980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62981       };
62982     } catch (std::exception& e) {
62983       {
62984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62985       };
62986     } catch (Dali::DaliException e) {
62987       {
62988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62989       };
62990     } catch (...) {
62991       {
62992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62993       };
62994     }
62995   }
62996
62997 }
62998
62999
63000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
63001   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63002   Dali::Actor *arg2 = 0 ;
63003
63004   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63005   arg2 = (Dali::Actor *)jarg2;
63006   if (!arg2) {
63007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63008     return ;
63009   }
63010   {
63011     try {
63012       (arg1)->OnControlChildAdd(*arg2);
63013     } catch (std::out_of_range& e) {
63014       {
63015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63016       };
63017     } catch (std::exception& e) {
63018       {
63019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63020       };
63021     } catch (Dali::DaliException e) {
63022       {
63023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63024       };
63025     } catch (...) {
63026       {
63027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63028       };
63029     }
63030   }
63031
63032 }
63033
63034
63035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63036   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63037   Dali::Actor *arg2 = 0 ;
63038
63039   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63040   arg2 = (Dali::Actor *)jarg2;
63041   if (!arg2) {
63042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63043     return ;
63044   }
63045   {
63046     try {
63047       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
63048     } catch (std::out_of_range& e) {
63049       {
63050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63051       };
63052     } catch (std::exception& e) {
63053       {
63054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63055       };
63056     } catch (Dali::DaliException e) {
63057       {
63058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63059       };
63060     } catch (...) {
63061       {
63062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63063       };
63064     }
63065   }
63066
63067 }
63068
63069
63070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
63071   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63072   Dali::Actor *arg2 = 0 ;
63073
63074   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63075   arg2 = (Dali::Actor *)jarg2;
63076   if (!arg2) {
63077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63078     return ;
63079   }
63080   {
63081     try {
63082       (arg1)->OnControlChildRemove(*arg2);
63083     } catch (std::out_of_range& e) {
63084       {
63085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63086       };
63087     } catch (std::exception& e) {
63088       {
63089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63090       };
63091     } catch (Dali::DaliException e) {
63092       {
63093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63094       };
63095     } catch (...) {
63096       {
63097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63098       };
63099     }
63100   }
63101
63102 }
63103
63104
63105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63106   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63107   Dali::Actor *arg2 = 0 ;
63108
63109   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63110   arg2 = (Dali::Actor *)jarg2;
63111   if (!arg2) {
63112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63113     return ;
63114   }
63115   {
63116     try {
63117       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
63118     } catch (std::out_of_range& e) {
63119       {
63120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63121       };
63122     } catch (std::exception& e) {
63123       {
63124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63125       };
63126     } catch (Dali::DaliException e) {
63127       {
63128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63129       };
63130     } catch (...) {
63131       {
63132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63133       };
63134     }
63135   }
63136
63137 }
63138
63139
63140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
63141   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63142   Dali::Toolkit::StyleManager arg2 ;
63143   Dali::StyleChange::Type arg3 ;
63144   Dali::Toolkit::StyleManager *argp2 ;
63145
63146   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63147   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
63148   if (!argp2) {
63149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
63150     return ;
63151   }
63152   arg2 = *argp2;
63153   arg3 = (Dali::StyleChange::Type)jarg3;
63154   {
63155     try {
63156       (arg1)->OnStyleChange(arg2,arg3);
63157     } catch (std::out_of_range& e) {
63158       {
63159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63160       };
63161     } catch (std::exception& e) {
63162       {
63163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63164       };
63165     } catch (Dali::DaliException e) {
63166       {
63167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63168       };
63169     } catch (...) {
63170       {
63171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63172       };
63173     }
63174   }
63175
63176 }
63177
63178
63179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
63180   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63181   Dali::Toolkit::StyleManager arg2 ;
63182   Dali::StyleChange::Type arg3 ;
63183   Dali::Toolkit::StyleManager *argp2 ;
63184
63185   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63186   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
63187   if (!argp2) {
63188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
63189     return ;
63190   }
63191   arg2 = *argp2;
63192   arg3 = (Dali::StyleChange::Type)jarg3;
63193   {
63194     try {
63195       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
63196     } catch (std::out_of_range& e) {
63197       {
63198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63199       };
63200     } catch (std::exception& e) {
63201       {
63202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63203       };
63204     } catch (Dali::DaliException e) {
63205       {
63206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63207       };
63208     } catch (...) {
63209       {
63210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63211       };
63212     }
63213   }
63214
63215 }
63216
63217
63218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
63219   unsigned int jresult ;
63220   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63221   bool result;
63222
63223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63224   {
63225     try {
63226       result = (bool)(arg1)->OnAccessibilityActivated();
63227     } catch (std::out_of_range& e) {
63228       {
63229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63230       };
63231     } catch (std::exception& e) {
63232       {
63233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63234       };
63235     } catch (Dali::DaliException e) {
63236       {
63237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63238       };
63239     } catch (...) {
63240       {
63241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63242       };
63243     }
63244   }
63245
63246   jresult = result;
63247   return jresult;
63248 }
63249
63250
63251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
63252   unsigned int jresult ;
63253   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63254   bool result;
63255
63256   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63257   {
63258     try {
63259       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
63260     } catch (std::out_of_range& e) {
63261       {
63262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63263       };
63264     } catch (std::exception& e) {
63265       {
63266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63267       };
63268     } catch (Dali::DaliException e) {
63269       {
63270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63271       };
63272     } catch (...) {
63273       {
63274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63275       };
63276     }
63277   }
63278
63279   jresult = result;
63280   return jresult;
63281 }
63282
63283
63284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
63285   unsigned int jresult ;
63286   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63287   Dali::PanGesture arg2 ;
63288   Dali::PanGesture *argp2 ;
63289   bool result;
63290
63291   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63292   argp2 = (Dali::PanGesture *)jarg2;
63293   if (!argp2) {
63294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
63295     return 0;
63296   }
63297   arg2 = *argp2;
63298   {
63299     try {
63300       result = (bool)(arg1)->OnAccessibilityPan(arg2);
63301     } catch (std::out_of_range& e) {
63302       {
63303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63304       };
63305     } catch (std::exception& e) {
63306       {
63307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63308       };
63309     } catch (Dali::DaliException e) {
63310       {
63311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63312       };
63313     } catch (...) {
63314       {
63315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63316       };
63317     }
63318   }
63319
63320   jresult = result;
63321   return jresult;
63322 }
63323
63324
63325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63326   unsigned int jresult ;
63327   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63328   Dali::PanGesture arg2 ;
63329   Dali::PanGesture *argp2 ;
63330   bool result;
63331
63332   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63333   argp2 = (Dali::PanGesture *)jarg2;
63334   if (!argp2) {
63335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
63336     return 0;
63337   }
63338   arg2 = *argp2;
63339   {
63340     try {
63341       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
63342     } catch (std::out_of_range& e) {
63343       {
63344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63345       };
63346     } catch (std::exception& e) {
63347       {
63348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63349       };
63350     } catch (Dali::DaliException e) {
63351       {
63352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63353       };
63354     } catch (...) {
63355       {
63356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63357       };
63358     }
63359   }
63360
63361   jresult = result;
63362   return jresult;
63363 }
63364
63365
63366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
63367   unsigned int jresult ;
63368   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63369   Dali::TouchEvent *arg2 = 0 ;
63370   bool result;
63371
63372   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63373   arg2 = (Dali::TouchEvent *)jarg2;
63374   if (!arg2) {
63375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
63376     return 0;
63377   }
63378   {
63379     try {
63380       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
63381     } catch (std::out_of_range& e) {
63382       {
63383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63384       };
63385     } catch (std::exception& e) {
63386       {
63387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63388       };
63389     } catch (Dali::DaliException e) {
63390       {
63391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63392       };
63393     } catch (...) {
63394       {
63395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63396       };
63397     }
63398   }
63399
63400   jresult = result;
63401   return jresult;
63402 }
63403
63404
63405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63406   unsigned int jresult ;
63407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63408   Dali::TouchEvent *arg2 = 0 ;
63409   bool result;
63410
63411   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63412   arg2 = (Dali::TouchEvent *)jarg2;
63413   if (!arg2) {
63414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
63415     return 0;
63416   }
63417   {
63418     try {
63419       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
63420     } catch (std::out_of_range& e) {
63421       {
63422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63423       };
63424     } catch (std::exception& e) {
63425       {
63426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63427       };
63428     } catch (Dali::DaliException e) {
63429       {
63430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63431       };
63432     } catch (...) {
63433       {
63434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63435       };
63436     }
63437   }
63438
63439   jresult = result;
63440   return jresult;
63441 }
63442
63443
63444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
63445   unsigned int jresult ;
63446   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63447   bool arg2 ;
63448   bool result;
63449
63450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63451   arg2 = jarg2 ? true : false;
63452   {
63453     try {
63454       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
63455     } catch (std::out_of_range& e) {
63456       {
63457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63458       };
63459     } catch (std::exception& e) {
63460       {
63461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63462       };
63463     } catch (Dali::DaliException e) {
63464       {
63465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63466       };
63467     } catch (...) {
63468       {
63469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63470       };
63471     }
63472   }
63473
63474   jresult = result;
63475   return jresult;
63476 }
63477
63478
63479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
63480   unsigned int jresult ;
63481   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63482   bool arg2 ;
63483   bool result;
63484
63485   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63486   arg2 = jarg2 ? true : false;
63487   {
63488     try {
63489       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
63490     } catch (std::out_of_range& e) {
63491       {
63492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63493       };
63494     } catch (std::exception& e) {
63495       {
63496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63497       };
63498     } catch (Dali::DaliException e) {
63499       {
63500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63501       };
63502     } catch (...) {
63503       {
63504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63505       };
63506     }
63507   }
63508
63509   jresult = result;
63510   return jresult;
63511 }
63512
63513
63514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
63515   unsigned int jresult ;
63516   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63517   bool result;
63518
63519   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63520   {
63521     try {
63522       result = (bool)(arg1)->OnAccessibilityZoom();
63523     } catch (std::out_of_range& e) {
63524       {
63525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63526       };
63527     } catch (std::exception& e) {
63528       {
63529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63530       };
63531     } catch (Dali::DaliException e) {
63532       {
63533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63534       };
63535     } catch (...) {
63536       {
63537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63538       };
63539     }
63540   }
63541
63542   jresult = result;
63543   return jresult;
63544 }
63545
63546
63547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
63548   unsigned int jresult ;
63549   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63550   bool result;
63551
63552   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63553   {
63554     try {
63555       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
63556     } catch (std::out_of_range& e) {
63557       {
63558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63559       };
63560     } catch (std::exception& e) {
63561       {
63562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63563       };
63564     } catch (Dali::DaliException e) {
63565       {
63566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63567       };
63568     } catch (...) {
63569       {
63570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63571       };
63572     }
63573   }
63574
63575   jresult = result;
63576   return jresult;
63577 }
63578
63579
63580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
63581   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63582
63583   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63584   {
63585     try {
63586       (arg1)->OnKeyInputFocusGained();
63587     } catch (std::out_of_range& e) {
63588       {
63589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63590       };
63591     } catch (std::exception& e) {
63592       {
63593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63594       };
63595     } catch (Dali::DaliException e) {
63596       {
63597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63598       };
63599     } catch (...) {
63600       {
63601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63602       };
63603     }
63604   }
63605
63606 }
63607
63608
63609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
63610   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63611
63612   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63613   {
63614     try {
63615       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
63616     } catch (std::out_of_range& e) {
63617       {
63618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63619       };
63620     } catch (std::exception& e) {
63621       {
63622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63623       };
63624     } catch (Dali::DaliException e) {
63625       {
63626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63627       };
63628     } catch (...) {
63629       {
63630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63631       };
63632     }
63633   }
63634
63635 }
63636
63637
63638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
63639   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63640
63641   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63642   {
63643     try {
63644       (arg1)->OnKeyInputFocusLost();
63645     } catch (std::out_of_range& e) {
63646       {
63647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63648       };
63649     } catch (std::exception& e) {
63650       {
63651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63652       };
63653     } catch (Dali::DaliException e) {
63654       {
63655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63656       };
63657     } catch (...) {
63658       {
63659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63660       };
63661     }
63662   }
63663
63664 }
63665
63666
63667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
63668   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63669
63670   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63671   {
63672     try {
63673       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
63674     } catch (std::out_of_range& e) {
63675       {
63676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63677       };
63678     } catch (std::exception& e) {
63679       {
63680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63681       };
63682     } catch (Dali::DaliException e) {
63683       {
63684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63685       };
63686     } catch (...) {
63687       {
63688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63689       };
63690     }
63691   }
63692
63693 }
63694
63695
63696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
63697   void * jresult ;
63698   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63699   Dali::Actor arg2 ;
63700   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
63701   bool arg4 ;
63702   Dali::Actor *argp2 ;
63703   Dali::Actor result;
63704
63705   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63706   argp2 = (Dali::Actor *)jarg2;
63707   if (!argp2) {
63708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63709     return 0;
63710   }
63711   arg2 = *argp2;
63712   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
63713   arg4 = jarg4 ? true : false;
63714   {
63715     try {
63716       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
63717     } catch (std::out_of_range& e) {
63718       {
63719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63720       };
63721     } catch (std::exception& e) {
63722       {
63723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63724       };
63725     } catch (Dali::DaliException e) {
63726       {
63727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63728       };
63729     } catch (...) {
63730       {
63731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63732       };
63733     }
63734   }
63735
63736   jresult = new Dali::Actor((const Dali::Actor &)result);
63737   return jresult;
63738 }
63739
63740
63741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
63742   void * jresult ;
63743   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63744   Dali::Actor arg2 ;
63745   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
63746   bool arg4 ;
63747   Dali::Actor *argp2 ;
63748   Dali::Actor result;
63749
63750   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63751   argp2 = (Dali::Actor *)jarg2;
63752   if (!argp2) {
63753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63754     return 0;
63755   }
63756   arg2 = *argp2;
63757   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
63758   arg4 = jarg4 ? true : false;
63759   {
63760     try {
63761       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
63762     } catch (std::out_of_range& e) {
63763       {
63764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63765       };
63766     } catch (std::exception& e) {
63767       {
63768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63769       };
63770     } catch (Dali::DaliException e) {
63771       {
63772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63773       };
63774     } catch (...) {
63775       {
63776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63777       };
63778     }
63779   }
63780
63781   jresult = new Dali::Actor((const Dali::Actor &)result);
63782   return jresult;
63783 }
63784
63785
63786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
63787   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63788   Dali::Actor arg2 ;
63789   Dali::Actor *argp2 ;
63790
63791   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63792   argp2 = (Dali::Actor *)jarg2;
63793   if (!argp2) {
63794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63795     return ;
63796   }
63797   arg2 = *argp2;
63798   {
63799     try {
63800       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
63801     } catch (std::out_of_range& e) {
63802       {
63803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63804       };
63805     } catch (std::exception& e) {
63806       {
63807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63808       };
63809     } catch (Dali::DaliException e) {
63810       {
63811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63812       };
63813     } catch (...) {
63814       {
63815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63816       };
63817     }
63818   }
63819
63820 }
63821
63822
63823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63824   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63825   Dali::Actor arg2 ;
63826   Dali::Actor *argp2 ;
63827
63828   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63829   argp2 = (Dali::Actor *)jarg2;
63830   if (!argp2) {
63831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63832     return ;
63833   }
63834   arg2 = *argp2;
63835   {
63836     try {
63837       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
63838     } catch (std::out_of_range& e) {
63839       {
63840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63841       };
63842     } catch (std::exception& e) {
63843       {
63844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63845       };
63846     } catch (Dali::DaliException e) {
63847       {
63848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63849       };
63850     } catch (...) {
63851       {
63852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63853       };
63854     }
63855   }
63856
63857 }
63858
63859
63860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
63861   unsigned int jresult ;
63862   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63863   bool result;
63864
63865   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63866   {
63867     try {
63868       result = (bool)(arg1)->OnKeyboardEnter();
63869     } catch (std::out_of_range& e) {
63870       {
63871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63872       };
63873     } catch (std::exception& e) {
63874       {
63875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63876       };
63877     } catch (Dali::DaliException e) {
63878       {
63879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63880       };
63881     } catch (...) {
63882       {
63883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63884       };
63885     }
63886   }
63887
63888   jresult = result;
63889   return jresult;
63890 }
63891
63892
63893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
63894   unsigned int jresult ;
63895   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63896   bool result;
63897
63898   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63899   {
63900     try {
63901       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
63902     } catch (std::out_of_range& e) {
63903       {
63904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63905       };
63906     } catch (std::exception& e) {
63907       {
63908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63909       };
63910     } catch (Dali::DaliException e) {
63911       {
63912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63913       };
63914     } catch (...) {
63915       {
63916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63917       };
63918     }
63919   }
63920
63921   jresult = result;
63922   return jresult;
63923 }
63924
63925
63926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
63927   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63928   Dali::PinchGesture *arg2 = 0 ;
63929
63930   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63931   arg2 = (Dali::PinchGesture *)jarg2;
63932   if (!arg2) {
63933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
63934     return ;
63935   }
63936   {
63937     try {
63938       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
63939     } catch (std::out_of_range& e) {
63940       {
63941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63942       };
63943     } catch (std::exception& e) {
63944       {
63945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63946       };
63947     } catch (Dali::DaliException e) {
63948       {
63949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63950       };
63951     } catch (...) {
63952       {
63953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63954       };
63955     }
63956   }
63957
63958 }
63959
63960
63961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63962   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63963   Dali::PinchGesture *arg2 = 0 ;
63964
63965   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63966   arg2 = (Dali::PinchGesture *)jarg2;
63967   if (!arg2) {
63968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
63969     return ;
63970   }
63971   {
63972     try {
63973       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
63974     } catch (std::out_of_range& e) {
63975       {
63976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63977       };
63978     } catch (std::exception& e) {
63979       {
63980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63981       };
63982     } catch (Dali::DaliException e) {
63983       {
63984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63985       };
63986     } catch (...) {
63987       {
63988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63989       };
63990     }
63991   }
63992
63993 }
63994
63995
63996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
63997   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63998   Dali::PanGesture *arg2 = 0 ;
63999
64000   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64001   arg2 = (Dali::PanGesture *)jarg2;
64002   if (!arg2) {
64003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
64004     return ;
64005   }
64006   {
64007     try {
64008       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
64009     } catch (std::out_of_range& e) {
64010       {
64011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64012       };
64013     } catch (std::exception& e) {
64014       {
64015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64016       };
64017     } catch (Dali::DaliException e) {
64018       {
64019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64020       };
64021     } catch (...) {
64022       {
64023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64024       };
64025     }
64026   }
64027
64028 }
64029
64030
64031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64032   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64033   Dali::PanGesture *arg2 = 0 ;
64034
64035   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64036   arg2 = (Dali::PanGesture *)jarg2;
64037   if (!arg2) {
64038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
64039     return ;
64040   }
64041   {
64042     try {
64043       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
64044     } catch (std::out_of_range& e) {
64045       {
64046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64047       };
64048     } catch (std::exception& e) {
64049       {
64050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64051       };
64052     } catch (Dali::DaliException e) {
64053       {
64054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64055       };
64056     } catch (...) {
64057       {
64058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64059       };
64060     }
64061   }
64062
64063 }
64064
64065
64066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
64067   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64068   Dali::TapGesture *arg2 = 0 ;
64069
64070   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64071   arg2 = (Dali::TapGesture *)jarg2;
64072   if (!arg2) {
64073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
64074     return ;
64075   }
64076   {
64077     try {
64078       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
64079     } catch (std::out_of_range& e) {
64080       {
64081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64082       };
64083     } catch (std::exception& e) {
64084       {
64085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64086       };
64087     } catch (Dali::DaliException e) {
64088       {
64089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64090       };
64091     } catch (...) {
64092       {
64093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64094       };
64095     }
64096   }
64097
64098 }
64099
64100
64101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64102   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64103   Dali::TapGesture *arg2 = 0 ;
64104
64105   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64106   arg2 = (Dali::TapGesture *)jarg2;
64107   if (!arg2) {
64108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
64109     return ;
64110   }
64111   {
64112     try {
64113       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
64114     } catch (std::out_of_range& e) {
64115       {
64116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64117       };
64118     } catch (std::exception& e) {
64119       {
64120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64121       };
64122     } catch (Dali::DaliException e) {
64123       {
64124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64125       };
64126     } catch (...) {
64127       {
64128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64129       };
64130     }
64131   }
64132
64133 }
64134
64135
64136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
64137   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64138   Dali::LongPressGesture *arg2 = 0 ;
64139
64140   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64141   arg2 = (Dali::LongPressGesture *)jarg2;
64142   if (!arg2) {
64143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
64144     return ;
64145   }
64146   {
64147     try {
64148       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
64149     } catch (std::out_of_range& e) {
64150       {
64151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64152       };
64153     } catch (std::exception& e) {
64154       {
64155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64156       };
64157     } catch (Dali::DaliException e) {
64158       {
64159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64160       };
64161     } catch (...) {
64162       {
64163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64164       };
64165     }
64166   }
64167
64168 }
64169
64170
64171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64172   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64173   Dali::LongPressGesture *arg2 = 0 ;
64174
64175   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64176   arg2 = (Dali::LongPressGesture *)jarg2;
64177   if (!arg2) {
64178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
64179     return ;
64180   }
64181   {
64182     try {
64183       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
64184     } catch (std::out_of_range& e) {
64185       {
64186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64187       };
64188     } catch (std::exception& e) {
64189       {
64190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64191       };
64192     } catch (Dali::DaliException e) {
64193       {
64194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64195       };
64196     } catch (...) {
64197       {
64198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64199       };
64200     }
64201   }
64202
64203 }
64204
64205
64206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
64207   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64208   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
64209   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
64210
64211   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64212   arg2 = (Dali::SlotObserver *)jarg2;
64213   arg3 = (Dali::CallbackBase *)jarg3;
64214   {
64215     try {
64216       (arg1)->SignalConnected(arg2,arg3);
64217     } catch (std::out_of_range& e) {
64218       {
64219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64220       };
64221     } catch (std::exception& e) {
64222       {
64223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64224       };
64225     } catch (Dali::DaliException e) {
64226       {
64227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64228       };
64229     } catch (...) {
64230       {
64231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64232       };
64233     }
64234   }
64235
64236 }
64237
64238
64239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64240   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64241   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
64242   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
64243
64244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64245   arg2 = (Dali::SlotObserver *)jarg2;
64246   arg3 = (Dali::CallbackBase *)jarg3;
64247   {
64248     try {
64249       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
64250     } catch (std::out_of_range& e) {
64251       {
64252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64253       };
64254     } catch (std::exception& e) {
64255       {
64256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64257       };
64258     } catch (Dali::DaliException e) {
64259       {
64260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64261       };
64262     } catch (...) {
64263       {
64264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64265       };
64266     }
64267   }
64268
64269 }
64270
64271
64272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
64273   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64274   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
64275   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
64276
64277   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64278   arg2 = (Dali::SlotObserver *)jarg2;
64279   arg3 = (Dali::CallbackBase *)jarg3;
64280   {
64281     try {
64282       (arg1)->SignalDisconnected(arg2,arg3);
64283     } catch (std::out_of_range& e) {
64284       {
64285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64286       };
64287     } catch (std::exception& e) {
64288       {
64289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64290       };
64291     } catch (Dali::DaliException e) {
64292       {
64293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64294       };
64295     } catch (...) {
64296       {
64297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64298       };
64299     }
64300   }
64301
64302 }
64303
64304
64305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64306   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64307   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
64308   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
64309
64310   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64311   arg2 = (Dali::SlotObserver *)jarg2;
64312   arg3 = (Dali::CallbackBase *)jarg3;
64313   {
64314     try {
64315       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
64316     } catch (std::out_of_range& e) {
64317       {
64318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64319       };
64320     } catch (std::exception& e) {
64321       {
64322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64323       };
64324     } catch (Dali::DaliException e) {
64325       {
64326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64327       };
64328     } catch (...) {
64329       {
64330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64331       };
64332     }
64333   }
64334
64335 }
64336
64337
64338 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) {
64339   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
64340   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
64341   if (director) {
64342     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);
64343   }
64344 }
64345
64346
64347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
64348   void * jresult ;
64349   Dali::Toolkit::Control *arg1 = 0 ;
64350   Dali::Toolkit::Internal::Control *result = 0 ;
64351
64352   arg1 = (Dali::Toolkit::Control *)jarg1;
64353   if (!arg1) {
64354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64355     return 0;
64356   }
64357   {
64358     try {
64359       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
64360     } catch (std::out_of_range& e) {
64361       {
64362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64363       };
64364     } catch (std::exception& e) {
64365       {
64366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64367       };
64368     } catch (Dali::DaliException e) {
64369       {
64370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64371       };
64372     } catch (...) {
64373       {
64374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64375       };
64376     }
64377   }
64378
64379   jresult = (void *)result;
64380   return jresult;
64381 }
64382
64383
64384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
64385   int jresult ;
64386   int result;
64387
64388   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
64389   jresult = (int)result;
64390   return jresult;
64391 }
64392
64393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
64394   int jresult ;
64395   int result;
64396
64397   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
64398   jresult = (int)result;
64399   return jresult;
64400 }
64401
64402
64403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
64404   int jresult ;
64405   int result;
64406
64407   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
64408   jresult = (int)result;
64409   return jresult;
64410 }
64411
64412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
64413   int jresult ;
64414   int result;
64415
64416   result = (int)Dali::Toolkit::Control::Property::MARGIN;
64417   jresult = (int)result;
64418   return jresult;
64419 }
64420
64421
64422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
64423   int jresult ;
64424   int result;
64425
64426   result = (int)Dali::Toolkit::Control::Property::PADDING;
64427   jresult = (int)result;
64428   return jresult;
64429 }
64430
64431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
64432   int jresult ;
64433   int result;
64434
64435   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
64436   jresult = (int)result;
64437   return jresult;
64438 }
64439
64440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
64441   void * jresult ;
64442   Dali::Toolkit::Control::Property *result = 0 ;
64443
64444   {
64445     try {
64446       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
64447     } catch (std::out_of_range& e) {
64448       {
64449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64450       };
64451     } catch (std::exception& e) {
64452       {
64453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64454       };
64455     } catch (Dali::DaliException e) {
64456       {
64457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64458       };
64459     } catch (...) {
64460       {
64461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64462       };
64463     }
64464   }
64465
64466   jresult = (void *)result;
64467   return jresult;
64468 }
64469
64470
64471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
64472   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
64473
64474   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
64475   {
64476     try {
64477       delete arg1;
64478     } catch (std::out_of_range& e) {
64479       {
64480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64481       };
64482     } catch (std::exception& e) {
64483       {
64484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64485       };
64486     } catch (Dali::DaliException e) {
64487       {
64488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64489       };
64490     } catch (...) {
64491       {
64492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64493       };
64494     }
64495   }
64496
64497 }
64498
64499
64500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
64501   void * jresult ;
64502   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
64503
64504   {
64505     try {
64506       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
64507     } catch (std::out_of_range& e) {
64508       {
64509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64510       };
64511     } catch (std::exception& e) {
64512       {
64513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64514       };
64515     } catch (Dali::DaliException e) {
64516       {
64517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64518       };
64519     } catch (...) {
64520       {
64521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64522       };
64523     }
64524   }
64525
64526   jresult = (void *)result;
64527   return jresult;
64528 }
64529
64530
64531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
64532   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
64533
64534   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
64535   {
64536     try {
64537       delete arg1;
64538     } catch (std::out_of_range& e) {
64539       {
64540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64541       };
64542     } catch (std::exception& e) {
64543       {
64544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64545       };
64546     } catch (Dali::DaliException e) {
64547       {
64548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64549       };
64550     } catch (...) {
64551       {
64552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64553       };
64554     }
64555   }
64556
64557 }
64558
64559
64560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
64561   void * jresult ;
64562   Dali::Toolkit::Control result;
64563
64564   {
64565     try {
64566       result = Dali::Toolkit::Control::New();
64567     } catch (std::out_of_range& e) {
64568       {
64569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64570       };
64571     } catch (std::exception& e) {
64572       {
64573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64574       };
64575     } catch (Dali::DaliException e) {
64576       {
64577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64578       };
64579     } catch (...) {
64580       {
64581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64582       };
64583     }
64584   }
64585
64586   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64587   return jresult;
64588 }
64589
64590
64591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
64592   void * jresult ;
64593   Dali::Toolkit::Control *result = 0 ;
64594
64595   {
64596     try {
64597       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
64598     } catch (std::out_of_range& e) {
64599       {
64600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64601       };
64602     } catch (std::exception& e) {
64603       {
64604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64605       };
64606     } catch (Dali::DaliException e) {
64607       {
64608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64609       };
64610     } catch (...) {
64611       {
64612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64613       };
64614     }
64615   }
64616
64617   jresult = (void *)result;
64618   return jresult;
64619 }
64620
64621
64622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
64623   void * jresult ;
64624   Dali::Toolkit::Control *arg1 = 0 ;
64625   Dali::Toolkit::Control *result = 0 ;
64626
64627   arg1 = (Dali::Toolkit::Control *)jarg1;
64628   if (!arg1) {
64629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
64630     return 0;
64631   }
64632   {
64633     try {
64634       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
64635     } catch (std::out_of_range& e) {
64636       {
64637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64638       };
64639     } catch (std::exception& e) {
64640       {
64641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64642       };
64643     } catch (Dali::DaliException e) {
64644       {
64645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64646       };
64647     } catch (...) {
64648       {
64649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64650       };
64651     }
64652   }
64653
64654   jresult = (void *)result;
64655   return jresult;
64656 }
64657
64658
64659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
64660   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64661
64662   arg1 = (Dali::Toolkit::Control *)jarg1;
64663   {
64664     try {
64665       delete arg1;
64666     } catch (std::out_of_range& e) {
64667       {
64668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64669       };
64670     } catch (std::exception& e) {
64671       {
64672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64673       };
64674     } catch (Dali::DaliException e) {
64675       {
64676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64677       };
64678     } catch (...) {
64679       {
64680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64681       };
64682     }
64683   }
64684
64685 }
64686
64687
64688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
64689   void * jresult ;
64690   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64691   Dali::Toolkit::Control *arg2 = 0 ;
64692   Dali::Toolkit::Control *result = 0 ;
64693
64694   arg1 = (Dali::Toolkit::Control *)jarg1;
64695   arg2 = (Dali::Toolkit::Control *)jarg2;
64696   if (!arg2) {
64697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
64698     return 0;
64699   }
64700   {
64701     try {
64702       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
64703     } catch (std::out_of_range& e) {
64704       {
64705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64706       };
64707     } catch (std::exception& e) {
64708       {
64709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64710       };
64711     } catch (Dali::DaliException e) {
64712       {
64713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64714       };
64715     } catch (...) {
64716       {
64717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64718       };
64719     }
64720   }
64721
64722   jresult = (void *)result;
64723   return jresult;
64724 }
64725
64726
64727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
64728   void * jresult ;
64729   Dali::BaseHandle arg1 ;
64730   Dali::BaseHandle *argp1 ;
64731   Dali::Toolkit::Control result;
64732
64733   argp1 = (Dali::BaseHandle *)jarg1;
64734   if (!argp1) {
64735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64736     return 0;
64737   }
64738   arg1 = *argp1;
64739   {
64740     try {
64741       result = Dali::Toolkit::Control::DownCast(arg1);
64742     } catch (std::out_of_range& e) {
64743       {
64744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64745       };
64746     } catch (std::exception& e) {
64747       {
64748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64749       };
64750     } catch (Dali::DaliException e) {
64751       {
64752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64753       };
64754     } catch (...) {
64755       {
64756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64757       };
64758     }
64759   }
64760
64761   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64762   return jresult;
64763 }
64764
64765
64766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
64767   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64768
64769   arg1 = (Dali::Toolkit::Control *)jarg1;
64770   {
64771     try {
64772       (arg1)->SetKeyInputFocus();
64773     } catch (std::out_of_range& e) {
64774       {
64775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64776       };
64777     } catch (std::exception& e) {
64778       {
64779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64780       };
64781     } catch (Dali::DaliException e) {
64782       {
64783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64784       };
64785     } catch (...) {
64786       {
64787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64788       };
64789     }
64790   }
64791
64792 }
64793
64794
64795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
64796   unsigned int jresult ;
64797   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64798   bool result;
64799
64800   arg1 = (Dali::Toolkit::Control *)jarg1;
64801   {
64802     try {
64803       result = (bool)(arg1)->HasKeyInputFocus();
64804     } catch (std::out_of_range& e) {
64805       {
64806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64807       };
64808     } catch (std::exception& e) {
64809       {
64810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64811       };
64812     } catch (Dali::DaliException e) {
64813       {
64814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64815       };
64816     } catch (...) {
64817       {
64818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64819       };
64820     }
64821   }
64822
64823   jresult = result;
64824   return jresult;
64825 }
64826
64827
64828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
64829   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64830
64831   arg1 = (Dali::Toolkit::Control *)jarg1;
64832   {
64833     try {
64834       (arg1)->ClearKeyInputFocus();
64835     } catch (std::out_of_range& e) {
64836       {
64837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64838       };
64839     } catch (std::exception& e) {
64840       {
64841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64842       };
64843     } catch (Dali::DaliException e) {
64844       {
64845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64846       };
64847     } catch (...) {
64848       {
64849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64850       };
64851     }
64852   }
64853
64854 }
64855
64856
64857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
64858   void * jresult ;
64859   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64860   Dali::PinchGestureDetector result;
64861
64862   arg1 = (Dali::Toolkit::Control *)jarg1;
64863   {
64864     try {
64865       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
64866     } catch (std::out_of_range& e) {
64867       {
64868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64869       };
64870     } catch (std::exception& e) {
64871       {
64872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64873       };
64874     } catch (Dali::DaliException e) {
64875       {
64876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64877       };
64878     } catch (...) {
64879       {
64880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64881       };
64882     }
64883   }
64884
64885   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
64886   return jresult;
64887 }
64888
64889
64890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
64891   void * jresult ;
64892   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64893   Dali::PanGestureDetector result;
64894
64895   arg1 = (Dali::Toolkit::Control *)jarg1;
64896   {
64897     try {
64898       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
64899     } catch (std::out_of_range& e) {
64900       {
64901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64902       };
64903     } catch (std::exception& e) {
64904       {
64905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64906       };
64907     } catch (Dali::DaliException e) {
64908       {
64909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64910       };
64911     } catch (...) {
64912       {
64913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64914       };
64915     }
64916   }
64917
64918   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
64919   return jresult;
64920 }
64921
64922
64923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
64924   void * jresult ;
64925   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64926   Dali::TapGestureDetector result;
64927
64928   arg1 = (Dali::Toolkit::Control *)jarg1;
64929   {
64930     try {
64931       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
64932     } catch (std::out_of_range& e) {
64933       {
64934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64935       };
64936     } catch (std::exception& e) {
64937       {
64938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64939       };
64940     } catch (Dali::DaliException e) {
64941       {
64942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64943       };
64944     } catch (...) {
64945       {
64946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64947       };
64948     }
64949   }
64950
64951   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
64952   return jresult;
64953 }
64954
64955
64956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
64957   void * jresult ;
64958   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64959   Dali::LongPressGestureDetector result;
64960
64961   arg1 = (Dali::Toolkit::Control *)jarg1;
64962   {
64963     try {
64964       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
64965     } catch (std::out_of_range& e) {
64966       {
64967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64968       };
64969     } catch (std::exception& e) {
64970       {
64971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64972       };
64973     } catch (Dali::DaliException e) {
64974       {
64975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64976       };
64977     } catch (...) {
64978       {
64979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64980       };
64981     }
64982   }
64983
64984   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
64985   return jresult;
64986 }
64987
64988
64989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
64990   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64991   std::string *arg2 = 0 ;
64992
64993   arg1 = (Dali::Toolkit::Control *)jarg1;
64994   if (!jarg2) {
64995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64996     return ;
64997   }
64998   std::string arg2_str(jarg2);
64999   arg2 = &arg2_str;
65000   {
65001     try {
65002       (arg1)->SetStyleName((std::string const &)*arg2);
65003     } catch (std::out_of_range& e) {
65004       {
65005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65006       };
65007     } catch (std::exception& e) {
65008       {
65009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65010       };
65011     } catch (Dali::DaliException e) {
65012       {
65013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65014       };
65015     } catch (...) {
65016       {
65017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65018       };
65019     }
65020   }
65021
65022
65023   //argout typemap for const std::string&
65024
65025 }
65026
65027
65028 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
65029   char * jresult ;
65030   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65031   std::string *result = 0 ;
65032
65033   arg1 = (Dali::Toolkit::Control *)jarg1;
65034   {
65035     try {
65036       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
65037     } catch (std::out_of_range& e) {
65038       {
65039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65040       };
65041     } catch (std::exception& e) {
65042       {
65043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65044       };
65045     } catch (Dali::DaliException e) {
65046       {
65047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65048       };
65049     } catch (...) {
65050       {
65051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65052       };
65053     }
65054   }
65055
65056   jresult = SWIG_csharp_string_callback(result->c_str());
65057   return jresult;
65058 }
65059
65060
65061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
65062   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65063   Dali::Vector4 *arg2 = 0 ;
65064
65065   arg1 = (Dali::Toolkit::Control *)jarg1;
65066   arg2 = (Dali::Vector4 *)jarg2;
65067   if (!arg2) {
65068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
65069     return ;
65070   }
65071   {
65072     try {
65073       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
65074     } catch (std::out_of_range& e) {
65075       {
65076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65077       };
65078     } catch (std::exception& e) {
65079       {
65080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65081       };
65082     } catch (Dali::DaliException e) {
65083       {
65084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65085       };
65086     } catch (...) {
65087       {
65088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65089       };
65090     }
65091   }
65092
65093 }
65094
65095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
65096   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65097
65098   arg1 = (Dali::Toolkit::Control *)jarg1;
65099   {
65100     try {
65101       (arg1)->ClearBackground();
65102     } catch (std::out_of_range& e) {
65103       {
65104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65105       };
65106     } catch (std::exception& e) {
65107       {
65108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65109       };
65110     } catch (Dali::DaliException e) {
65111       {
65112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65113       };
65114     } catch (...) {
65115       {
65116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65117       };
65118     }
65119   }
65120
65121 }
65122
65123
65124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
65125   void * jresult ;
65126   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65127   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
65128
65129   arg1 = (Dali::Toolkit::Control *)jarg1;
65130   {
65131     try {
65132       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
65133     } catch (std::out_of_range& e) {
65134       {
65135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65136       };
65137     } catch (std::exception& e) {
65138       {
65139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65140       };
65141     } catch (Dali::DaliException e) {
65142       {
65143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65144       };
65145     } catch (...) {
65146       {
65147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65148       };
65149     }
65150   }
65151
65152   jresult = (void *)result;
65153   return jresult;
65154 }
65155
65156
65157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
65158   void * jresult ;
65159   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65160   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
65161
65162   arg1 = (Dali::Toolkit::Control *)jarg1;
65163   {
65164     try {
65165       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
65166     } catch (std::out_of_range& e) {
65167       {
65168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65169       };
65170     } catch (std::exception& e) {
65171       {
65172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65173       };
65174     } catch (Dali::DaliException e) {
65175       {
65176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65177       };
65178     } catch (...) {
65179       {
65180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65181       };
65182     }
65183   }
65184
65185   jresult = (void *)result;
65186   return jresult;
65187 }
65188
65189
65190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
65191   void * jresult ;
65192   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65193   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
65194
65195   arg1 = (Dali::Toolkit::Control *)jarg1;
65196   {
65197     try {
65198       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
65199     } catch (std::out_of_range& e) {
65200       {
65201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65202       };
65203     } catch (std::exception& e) {
65204       {
65205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65206       };
65207     } catch (Dali::DaliException e) {
65208       {
65209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65210       };
65211     } catch (...) {
65212       {
65213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65214       };
65215     }
65216   }
65217
65218   jresult = (void *)result;
65219   return jresult;
65220 }
65221
65222
65223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
65224   void * jresult ;
65225   Dali::Toolkit::Internal::Control *arg1 = 0 ;
65226   Dali::Toolkit::Control *result = 0 ;
65227
65228   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65229   if (!arg1) {
65230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
65231     return 0;
65232   }
65233   {
65234     try {
65235       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
65236     } catch (std::out_of_range& e) {
65237       {
65238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65239       };
65240     } catch (std::exception& e) {
65241       {
65242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65243       };
65244     } catch (Dali::DaliException e) {
65245       {
65246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65247       };
65248     } catch (...) {
65249       {
65250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65251       };
65252     }
65253   }
65254
65255   jresult = (void *)result;
65256   return jresult;
65257 }
65258
65259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
65260 {
65261   int jresult;
65262   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65263   arg1 = (Dali::Toolkit::Control *)jarg1;
65264
65265   if (!arg1) {
65266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
65267     return 0;
65268   }
65269
65270   Dali::Property::Index arg2 = 0 ;
65271   arg2 = (Dali::Property::Index)jarg2;
65272
65273   Toolkit::Visual::ResourceStatus result;
65274   {
65275     try {
65276       result = arg1->GetVisualResourceStatus(arg2);
65277     } catch (std::out_of_range& e) {
65278       {
65279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65280       };
65281     } catch (std::exception& e) {
65282       {
65283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65284       };
65285     } catch (...) {
65286       {
65287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65288       };
65289     }
65290   }
65291   jresult = (int)(result);
65292   return jresult;
65293 }
65294
65295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
65296 {
65297   void * jresult;
65298   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65299   arg1 = (Dali::Toolkit::Control *)jarg1;
65300
65301   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
65302
65303   Dali::Toolkit::TransitionData *arg2 = 0 ;
65304   Dali::Animation result;
65305
65306   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
65307   if (!arg2) {
65308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
65309     return 0;
65310   }
65311   {
65312     try {
65313       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
65314     } catch (std::out_of_range& e) {
65315       {
65316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65317       };
65318     } catch (std::exception& e) {
65319       {
65320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65321       };
65322     } catch (Dali::DaliException e) {
65323       {
65324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65325       };
65326     } catch (...) {
65327       {
65328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65329       };
65330     }
65331   }
65332
65333   jresult = new Dali::Animation((const Dali::Animation &)result);
65334   return jresult;
65335 }
65336
65337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
65338 {
65339   Dali::Toolkit::Control arg1;
65340   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
65341
65342   if (!argp1) {
65343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
65344   }
65345   arg1 = *argp1;
65346
65347   Dali::Property::Index arg2 = 0 ;
65348   arg2 = (Dali::Property::Index)jarg2;
65349
65350   Dali::Property::Index arg3 = 0 ;
65351   arg3 = (Dali::Property::Index)jarg3;
65352
65353   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
65354
65355   {
65356     try {
65357       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
65358     } catch (std::out_of_range& e) {
65359       {
65360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65361       };
65362     } catch (std::exception& e) {
65363       {
65364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65365       };
65366     } catch (...) {
65367       {
65368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65369       };
65370     }
65371   }
65372
65373
65374 }
65375
65376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
65377   void * jresult ;
65378   Dali::Toolkit::Control *arg1 = 0 ;
65379   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
65380
65381   arg1 = (Dali::Toolkit::Control *)jarg1;
65382   if (!arg1) {
65383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
65384     return 0;
65385   }
65386   {
65387     try {
65388       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
65389     } catch (std::out_of_range& e) {
65390       {
65391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65392       };
65393     } catch (std::exception& e) {
65394       {
65395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65396       };
65397     } catch (Dali::DaliException e) {
65398       {
65399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65400       };
65401     } catch (...) {
65402       {
65403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65404       };
65405     }
65406   }
65407
65408   jresult = (void *)result;
65409   return jresult;
65410 }
65411
65412
65413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
65414   unsigned int jresult ;
65415   Dali::Toolkit::Control *arg1 = 0 ;
65416   bool result;
65417
65418   arg1 = (Dali::Toolkit::Control *)jarg1;
65419   if (!arg1) {
65420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
65421     return 0;
65422   }
65423   {
65424     try {
65425       result = (bool)arg1->IsResourceReady();
65426     } catch (std::out_of_range& e) {
65427       {
65428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65429       };
65430     } catch (std::exception& e) {
65431       {
65432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65433       };
65434     } catch (Dali::DaliException e) {
65435       {
65436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65437       };
65438     } catch (...) {
65439       {
65440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65441       };
65442     }
65443   }
65444
65445   jresult = result;
65446   return jresult;
65447 }
65448
65449
65450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
65451   void * jresult ;
65452   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
65453
65454   {
65455     try {
65456       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
65457     } catch (std::out_of_range& e) {
65458       {
65459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65460       };
65461     } catch (std::exception& e) {
65462       {
65463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65464       };
65465     } catch (Dali::DaliException e) {
65466       {
65467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65468       };
65469     } catch (...) {
65470       {
65471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65472       };
65473     }
65474   }
65475
65476   jresult = (void *)result;
65477   return jresult;
65478 }
65479
65480
65481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
65482   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
65483
65484   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
65485   {
65486     try {
65487       delete arg1;
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_KeyInputFocusManager_Get() {
65511   void * jresult ;
65512   Dali::Toolkit::KeyInputFocusManager result;
65513
65514   {
65515     try {
65516       result = Dali::Toolkit::KeyInputFocusManager::Get();
65517     } catch (std::out_of_range& e) {
65518       {
65519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65520       };
65521     } catch (std::exception& e) {
65522       {
65523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65524       };
65525     } catch (Dali::DaliException e) {
65526       {
65527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65528       };
65529     } catch (...) {
65530       {
65531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65532       };
65533     }
65534   }
65535
65536   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
65537   return jresult;
65538 }
65539
65540
65541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
65542   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
65543   Dali::Toolkit::Control arg2 ;
65544   Dali::Toolkit::Control *argp2 ;
65545
65546   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
65547   argp2 = (Dali::Toolkit::Control *)jarg2;
65548   if (!argp2) {
65549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
65550     return ;
65551   }
65552   arg2 = *argp2;
65553   {
65554     try {
65555       (arg1)->SetFocus(arg2);
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_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
65579   void * jresult ;
65580   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
65581   Dali::Toolkit::Control result;
65582
65583   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
65584   {
65585     try {
65586       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
65587     } catch (std::out_of_range& e) {
65588       {
65589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65590       };
65591     } catch (std::exception& e) {
65592       {
65593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65594       };
65595     } catch (Dali::DaliException e) {
65596       {
65597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65598       };
65599     } catch (...) {
65600       {
65601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65602       };
65603     }
65604   }
65605
65606   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
65607   return jresult;
65608 }
65609
65610
65611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
65612   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
65613   Dali::Toolkit::Control arg2 ;
65614   Dali::Toolkit::Control *argp2 ;
65615
65616   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
65617   argp2 = (Dali::Toolkit::Control *)jarg2;
65618   if (!argp2) {
65619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
65620     return ;
65621   }
65622   arg2 = *argp2;
65623   {
65624     try {
65625       (arg1)->RemoveFocus(arg2);
65626     } catch (std::out_of_range& e) {
65627       {
65628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65629       };
65630     } catch (std::exception& e) {
65631       {
65632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65633       };
65634     } catch (Dali::DaliException e) {
65635       {
65636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65637       };
65638     } catch (...) {
65639       {
65640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65641       };
65642     }
65643   }
65644
65645 }
65646
65647
65648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
65649   void * jresult ;
65650   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
65651   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
65652
65653   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
65654   {
65655     try {
65656       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
65657     } catch (std::out_of_range& e) {
65658       {
65659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65660       };
65661     } catch (std::exception& e) {
65662       {
65663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65664       };
65665     } catch (Dali::DaliException e) {
65666       {
65667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65668       };
65669     } catch (...) {
65670       {
65671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65672       };
65673     }
65674   }
65675
65676   jresult = (void *)result;
65677   return jresult;
65678 }
65679
65680
65681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
65682   void * jresult ;
65683   Dali::Toolkit::Alignment::Padding *result = 0 ;
65684
65685   {
65686     try {
65687       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
65688     } catch (std::out_of_range& e) {
65689       {
65690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65691       };
65692     } catch (std::exception& e) {
65693       {
65694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65695       };
65696     } catch (Dali::DaliException e) {
65697       {
65698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65699       };
65700     } catch (...) {
65701       {
65702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65703       };
65704     }
65705   }
65706
65707   jresult = (void *)result;
65708   return jresult;
65709 }
65710
65711
65712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
65713   void * jresult ;
65714   float arg1 ;
65715   float arg2 ;
65716   float arg3 ;
65717   float arg4 ;
65718   Dali::Toolkit::Alignment::Padding *result = 0 ;
65719
65720   arg1 = (float)jarg1;
65721   arg2 = (float)jarg2;
65722   arg3 = (float)jarg3;
65723   arg4 = (float)jarg4;
65724   {
65725     try {
65726       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
65727     } catch (std::out_of_range& e) {
65728       {
65729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65730       };
65731     } catch (std::exception& e) {
65732       {
65733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65734       };
65735     } catch (Dali::DaliException e) {
65736       {
65737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65738       };
65739     } catch (...) {
65740       {
65741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65742       };
65743     }
65744   }
65745
65746   jresult = (void *)result;
65747   return jresult;
65748 }
65749
65750
65751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
65752   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
65753   float arg2 ;
65754
65755   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
65756   arg2 = (float)jarg2;
65757   if (arg1) (arg1)->left = arg2;
65758 }
65759
65760
65761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
65762   float jresult ;
65763   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
65764   float result;
65765
65766   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
65767   result = (float) ((arg1)->left);
65768   jresult = result;
65769   return jresult;
65770 }
65771
65772
65773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
65774   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
65775   float arg2 ;
65776
65777   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
65778   arg2 = (float)jarg2;
65779   if (arg1) (arg1)->right = arg2;
65780 }
65781
65782
65783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
65784   float jresult ;
65785   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
65786   float result;
65787
65788   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
65789   result = (float) ((arg1)->right);
65790   jresult = result;
65791   return jresult;
65792 }
65793
65794
65795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
65796   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
65797   float arg2 ;
65798
65799   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
65800   arg2 = (float)jarg2;
65801   if (arg1) (arg1)->top = arg2;
65802 }
65803
65804
65805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
65806   float jresult ;
65807   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
65808   float result;
65809
65810   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
65811   result = (float) ((arg1)->top);
65812   jresult = result;
65813   return jresult;
65814 }
65815
65816
65817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
65818   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
65819   float arg2 ;
65820
65821   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
65822   arg2 = (float)jarg2;
65823   if (arg1) (arg1)->bottom = arg2;
65824 }
65825
65826
65827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
65828   float jresult ;
65829   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
65830   float result;
65831
65832   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
65833   result = (float) ((arg1)->bottom);
65834   jresult = result;
65835   return jresult;
65836 }
65837
65838
65839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
65840   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
65841
65842   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
65843   {
65844     try {
65845       delete arg1;
65846     } catch (std::out_of_range& e) {
65847       {
65848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65849       };
65850     } catch (std::exception& e) {
65851       {
65852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65853       };
65854     } catch (Dali::DaliException e) {
65855       {
65856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65857       };
65858     } catch (...) {
65859       {
65860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65861       };
65862     }
65863   }
65864
65865 }
65866
65867
65868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
65869   void * jresult ;
65870   Dali::Toolkit::Alignment *result = 0 ;
65871
65872   {
65873     try {
65874       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
65875     } catch (std::out_of_range& e) {
65876       {
65877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65878       };
65879     } catch (std::exception& e) {
65880       {
65881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65882       };
65883     } catch (Dali::DaliException e) {
65884       {
65885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65886       };
65887     } catch (...) {
65888       {
65889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65890       };
65891     }
65892   }
65893
65894   jresult = (void *)result;
65895   return jresult;
65896 }
65897
65898
65899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
65900   void * jresult ;
65901   Dali::Toolkit::Alignment::Type arg1 ;
65902   Dali::Toolkit::Alignment::Type arg2 ;
65903   Dali::Toolkit::Alignment result;
65904
65905   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
65906   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
65907   {
65908     try {
65909       result = Dali::Toolkit::Alignment::New(arg1,arg2);
65910     } catch (std::out_of_range& e) {
65911       {
65912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65913       };
65914     } catch (std::exception& e) {
65915       {
65916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65917       };
65918     } catch (Dali::DaliException e) {
65919       {
65920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65921       };
65922     } catch (...) {
65923       {
65924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65925       };
65926     }
65927   }
65928
65929   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
65930   return jresult;
65931 }
65932
65933
65934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
65935   void * jresult ;
65936   Dali::Toolkit::Alignment::Type arg1 ;
65937   Dali::Toolkit::Alignment result;
65938
65939   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
65940   {
65941     try {
65942       result = Dali::Toolkit::Alignment::New(arg1);
65943     } catch (std::out_of_range& e) {
65944       {
65945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65946       };
65947     } catch (std::exception& e) {
65948       {
65949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65950       };
65951     } catch (Dali::DaliException e) {
65952       {
65953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65954       };
65955     } catch (...) {
65956       {
65957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65958       };
65959     }
65960   }
65961
65962   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
65963   return jresult;
65964 }
65965
65966
65967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
65968   void * jresult ;
65969   Dali::Toolkit::Alignment result;
65970
65971   {
65972     try {
65973       result = Dali::Toolkit::Alignment::New();
65974     } catch (std::out_of_range& e) {
65975       {
65976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65977       };
65978     } catch (std::exception& e) {
65979       {
65980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65981       };
65982     } catch (Dali::DaliException e) {
65983       {
65984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65985       };
65986     } catch (...) {
65987       {
65988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65989       };
65990     }
65991   }
65992
65993   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
65994   return jresult;
65995 }
65996
65997
65998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
65999   void * jresult ;
66000   Dali::Toolkit::Alignment *arg1 = 0 ;
66001   Dali::Toolkit::Alignment *result = 0 ;
66002
66003   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66004   if (!arg1) {
66005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
66006     return 0;
66007   }
66008   {
66009     try {
66010       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
66011     } catch (std::out_of_range& e) {
66012       {
66013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66014       };
66015     } catch (std::exception& e) {
66016       {
66017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66018       };
66019     } catch (Dali::DaliException e) {
66020       {
66021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66022       };
66023     } catch (...) {
66024       {
66025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66026       };
66027     }
66028   }
66029
66030   jresult = (void *)result;
66031   return jresult;
66032 }
66033
66034
66035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
66036   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
66037
66038   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66039   {
66040     try {
66041       delete arg1;
66042     } catch (std::out_of_range& e) {
66043       {
66044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66045       };
66046     } catch (std::exception& e) {
66047       {
66048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66049       };
66050     } catch (Dali::DaliException e) {
66051       {
66052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66053       };
66054     } catch (...) {
66055       {
66056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66057       };
66058     }
66059   }
66060
66061 }
66062
66063
66064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
66065   void * jresult ;
66066   Dali::BaseHandle arg1 ;
66067   Dali::BaseHandle *argp1 ;
66068   Dali::Toolkit::Alignment result;
66069
66070   argp1 = (Dali::BaseHandle *)jarg1;
66071   if (!argp1) {
66072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66073     return 0;
66074   }
66075   arg1 = *argp1;
66076   {
66077     try {
66078       result = Dali::Toolkit::Alignment::DownCast(arg1);
66079     } catch (std::out_of_range& e) {
66080       {
66081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66082       };
66083     } catch (std::exception& e) {
66084       {
66085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66086       };
66087     } catch (Dali::DaliException e) {
66088       {
66089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66090       };
66091     } catch (...) {
66092       {
66093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66094       };
66095     }
66096   }
66097
66098   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
66099   return jresult;
66100 }
66101
66102
66103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
66104   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
66105   Dali::Toolkit::Alignment::Type arg2 ;
66106
66107   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66108   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
66109   {
66110     try {
66111       (arg1)->SetAlignmentType(arg2);
66112     } catch (std::out_of_range& e) {
66113       {
66114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66115       };
66116     } catch (std::exception& e) {
66117       {
66118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66119       };
66120     } catch (Dali::DaliException e) {
66121       {
66122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66123       };
66124     } catch (...) {
66125       {
66126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66127       };
66128     }
66129   }
66130
66131 }
66132
66133
66134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
66135   int jresult ;
66136   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
66137   Dali::Toolkit::Alignment::Type result;
66138
66139   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66140   {
66141     try {
66142       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
66143     } catch (std::out_of_range& e) {
66144       {
66145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66146       };
66147     } catch (std::exception& e) {
66148       {
66149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66150       };
66151     } catch (Dali::DaliException e) {
66152       {
66153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66154       };
66155     } catch (...) {
66156       {
66157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66158       };
66159     }
66160   }
66161
66162   jresult = (int)result;
66163   return jresult;
66164 }
66165
66166
66167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
66168   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
66169   Dali::Toolkit::Alignment::Scaling arg2 ;
66170
66171   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66172   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
66173   {
66174     try {
66175       (arg1)->SetScaling(arg2);
66176     } catch (std::out_of_range& e) {
66177       {
66178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66179       };
66180     } catch (std::exception& e) {
66181       {
66182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66183       };
66184     } catch (Dali::DaliException e) {
66185       {
66186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66187       };
66188     } catch (...) {
66189       {
66190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66191       };
66192     }
66193   }
66194
66195 }
66196
66197
66198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
66199   int jresult ;
66200   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
66201   Dali::Toolkit::Alignment::Scaling result;
66202
66203   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66204   {
66205     try {
66206       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
66207     } catch (std::out_of_range& e) {
66208       {
66209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66210       };
66211     } catch (std::exception& e) {
66212       {
66213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66214       };
66215     } catch (Dali::DaliException e) {
66216       {
66217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66218       };
66219     } catch (...) {
66220       {
66221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66222       };
66223     }
66224   }
66225
66226   jresult = (int)result;
66227   return jresult;
66228 }
66229
66230
66231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
66232   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
66233   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
66234
66235   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66236   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
66237   if (!arg2) {
66238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
66239     return ;
66240   }
66241   {
66242     try {
66243       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
66244     } catch (std::out_of_range& e) {
66245       {
66246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66247       };
66248     } catch (std::exception& e) {
66249       {
66250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66251       };
66252     } catch (Dali::DaliException e) {
66253       {
66254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66255       };
66256     } catch (...) {
66257       {
66258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66259       };
66260     }
66261   }
66262
66263 }
66264
66265
66266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
66267   void * jresult ;
66268   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
66269   Dali::Toolkit::Alignment::Padding *result = 0 ;
66270
66271   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66272   {
66273     try {
66274       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
66275     } catch (std::out_of_range& e) {
66276       {
66277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66278       };
66279     } catch (std::exception& e) {
66280       {
66281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66282       };
66283     } catch (Dali::DaliException e) {
66284       {
66285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66286       };
66287     } catch (...) {
66288       {
66289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66290       };
66291     }
66292   }
66293
66294   jresult = (void *)result;
66295   return jresult;
66296 }
66297
66298
66299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
66300   void * jresult ;
66301   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
66302   Dali::Toolkit::Alignment *arg2 = 0 ;
66303   Dali::Toolkit::Alignment *result = 0 ;
66304
66305   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66306   arg2 = (Dali::Toolkit::Alignment *)jarg2;
66307   if (!arg2) {
66308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
66309     return 0;
66310   }
66311   {
66312     try {
66313       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
66314     } catch (std::out_of_range& e) {
66315       {
66316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66317       };
66318     } catch (std::exception& e) {
66319       {
66320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66321       };
66322     } catch (Dali::DaliException e) {
66323       {
66324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66325       };
66326     } catch (...) {
66327       {
66328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66329       };
66330     }
66331   }
66332
66333   jresult = (void *)result;
66334   return jresult;
66335 }
66336
66337
66338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
66339   int jresult ;
66340   int result;
66341
66342   result = (int)Dali::Toolkit::Button::Property::DISABLED;
66343   jresult = (int)result;
66344   return jresult;
66345 }
66346
66347
66348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
66349   int jresult ;
66350   int result;
66351
66352   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
66353   jresult = (int)result;
66354   return jresult;
66355 }
66356
66357
66358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
66359   int jresult ;
66360   int result;
66361
66362   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
66363   jresult = (int)result;
66364   return jresult;
66365 }
66366
66367
66368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
66369   int jresult ;
66370   int result;
66371
66372   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
66373   jresult = (int)result;
66374   return jresult;
66375 }
66376
66377
66378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
66379   int jresult ;
66380   int result;
66381
66382   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
66383   jresult = (int)result;
66384   return jresult;
66385 }
66386
66387
66388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
66389   int jresult ;
66390   int result;
66391
66392   result = (int)Dali::Toolkit::Button::Property::SELECTED;
66393   jresult = (int)result;
66394   return jresult;
66395 }
66396
66397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
66398   int jresult ;
66399   int result;
66400
66401   result = (int)Dali::Toolkit::Button::Property::LABEL;
66402   jresult = (int)result;
66403   return jresult;
66404 }
66405
66406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
66407   void * jresult ;
66408   Dali::Toolkit::Button::Property *result = 0 ;
66409
66410   {
66411     try {
66412       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
66413     } catch (std::out_of_range& e) {
66414       {
66415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66416       };
66417     } catch (std::exception& e) {
66418       {
66419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66420       };
66421     } catch (Dali::DaliException e) {
66422       {
66423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66424       };
66425     } catch (...) {
66426       {
66427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66428       };
66429     }
66430   }
66431
66432   jresult = (void *)result;
66433   return jresult;
66434 }
66435
66436
66437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
66438   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
66439
66440   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
66441   {
66442     try {
66443       delete arg1;
66444     } catch (std::out_of_range& e) {
66445       {
66446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66447       };
66448     } catch (std::exception& e) {
66449       {
66450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66451       };
66452     } catch (Dali::DaliException e) {
66453       {
66454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66455       };
66456     } catch (...) {
66457       {
66458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66459       };
66460     }
66461   }
66462
66463 }
66464
66465
66466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
66467   void * jresult ;
66468   Dali::Toolkit::Button *result = 0 ;
66469
66470   {
66471     try {
66472       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
66473     } catch (std::out_of_range& e) {
66474       {
66475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66476       };
66477     } catch (std::exception& e) {
66478       {
66479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66480       };
66481     } catch (Dali::DaliException e) {
66482       {
66483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66484       };
66485     } catch (...) {
66486       {
66487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66488       };
66489     }
66490   }
66491
66492   jresult = (void *)result;
66493   return jresult;
66494 }
66495
66496
66497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
66498   void * jresult ;
66499   Dali::Toolkit::Button *arg1 = 0 ;
66500   Dali::Toolkit::Button *result = 0 ;
66501
66502   arg1 = (Dali::Toolkit::Button *)jarg1;
66503   if (!arg1) {
66504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
66505     return 0;
66506   }
66507   {
66508     try {
66509       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
66510     } catch (std::out_of_range& e) {
66511       {
66512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66513       };
66514     } catch (std::exception& e) {
66515       {
66516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66517       };
66518     } catch (Dali::DaliException e) {
66519       {
66520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66521       };
66522     } catch (...) {
66523       {
66524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66525       };
66526     }
66527   }
66528
66529   jresult = (void *)result;
66530   return jresult;
66531 }
66532
66533
66534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
66535   void * jresult ;
66536   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
66537   Dali::Toolkit::Button *arg2 = 0 ;
66538   Dali::Toolkit::Button *result = 0 ;
66539
66540   arg1 = (Dali::Toolkit::Button *)jarg1;
66541   arg2 = (Dali::Toolkit::Button *)jarg2;
66542   if (!arg2) {
66543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
66544     return 0;
66545   }
66546   {
66547     try {
66548       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
66549     } catch (std::out_of_range& e) {
66550       {
66551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66552       };
66553     } catch (std::exception& e) {
66554       {
66555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66556       };
66557     } catch (Dali::DaliException e) {
66558       {
66559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66560       };
66561     } catch (...) {
66562       {
66563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66564       };
66565     }
66566   }
66567
66568   jresult = (void *)result;
66569   return jresult;
66570 }
66571
66572
66573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
66574   void * jresult ;
66575   Dali::BaseHandle arg1 ;
66576   Dali::BaseHandle *argp1 ;
66577   Dali::Toolkit::Button result;
66578
66579   argp1 = (Dali::BaseHandle *)jarg1;
66580   if (!argp1) {
66581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66582     return 0;
66583   }
66584   arg1 = *argp1;
66585   {
66586     try {
66587       result = Dali::Toolkit::Button::DownCast(arg1);
66588     } catch (std::out_of_range& e) {
66589       {
66590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66591       };
66592     } catch (std::exception& e) {
66593       {
66594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66595       };
66596     } catch (Dali::DaliException e) {
66597       {
66598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66599       };
66600     } catch (...) {
66601       {
66602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66603       };
66604     }
66605   }
66606
66607   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
66608   return jresult;
66609 }
66610
66611
66612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
66613   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
66614
66615   arg1 = (Dali::Toolkit::Button *)jarg1;
66616   {
66617     try {
66618       delete arg1;
66619     } catch (std::out_of_range& e) {
66620       {
66621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66622       };
66623     } catch (std::exception& e) {
66624       {
66625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66626       };
66627     } catch (Dali::DaliException e) {
66628       {
66629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66630       };
66631     } catch (...) {
66632       {
66633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66634       };
66635     }
66636   }
66637
66638 }
66639
66640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
66641   void * jresult ;
66642   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
66643   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
66644
66645   arg1 = (Dali::Toolkit::Button *)jarg1;
66646   {
66647     try {
66648       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
66649     } catch (std::out_of_range& e) {
66650       {
66651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66652       };
66653     } catch (std::exception& e) {
66654       {
66655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66656       };
66657     } catch (Dali::DaliException e) {
66658       {
66659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66660       };
66661     } catch (...) {
66662       {
66663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66664       };
66665     }
66666   }
66667
66668   jresult = (void *)result;
66669   return jresult;
66670 }
66671
66672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
66673   void * jresult ;
66674   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
66675   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
66676
66677   arg1 = (Dali::Toolkit::Button *)jarg1;
66678   {
66679     try {
66680       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
66681     } catch (std::out_of_range& e) {
66682       {
66683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66684       };
66685     } catch (std::exception& e) {
66686       {
66687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66688       };
66689     } catch (Dali::DaliException e) {
66690       {
66691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66692       };
66693     } catch (...) {
66694       {
66695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66696       };
66697     }
66698   }
66699
66700   jresult = (void *)result;
66701   return jresult;
66702 }
66703
66704
66705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
66706   void * jresult ;
66707   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
66708   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
66709
66710   arg1 = (Dali::Toolkit::Button *)jarg1;
66711   {
66712     try {
66713       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
66714     } catch (std::out_of_range& e) {
66715       {
66716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66717       };
66718     } catch (std::exception& e) {
66719       {
66720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66721       };
66722     } catch (Dali::DaliException e) {
66723       {
66724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66725       };
66726     } catch (...) {
66727       {
66728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66729       };
66730     }
66731   }
66732
66733   jresult = (void *)result;
66734   return jresult;
66735 }
66736
66737
66738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
66739   void * jresult ;
66740   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
66741   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
66742
66743   arg1 = (Dali::Toolkit::Button *)jarg1;
66744   {
66745     try {
66746       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
66747     } catch (std::out_of_range& e) {
66748       {
66749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66750       };
66751     } catch (std::exception& e) {
66752       {
66753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66754       };
66755     } catch (Dali::DaliException e) {
66756       {
66757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66758       };
66759     } catch (...) {
66760       {
66761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66762       };
66763     }
66764   }
66765
66766   jresult = (void *)result;
66767   return jresult;
66768 }
66769
66770
66771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
66772   void * jresult ;
66773   Dali::Toolkit::CheckBoxButton *result = 0 ;
66774
66775   {
66776     try {
66777       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
66778     } catch (std::out_of_range& e) {
66779       {
66780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66781       };
66782     } catch (std::exception& e) {
66783       {
66784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66785       };
66786     } catch (Dali::DaliException e) {
66787       {
66788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66789       };
66790     } catch (...) {
66791       {
66792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66793       };
66794     }
66795   }
66796
66797   jresult = (void *)result;
66798   return jresult;
66799 }
66800
66801
66802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
66803   void * jresult ;
66804   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
66805   Dali::Toolkit::CheckBoxButton *result = 0 ;
66806
66807   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
66808   if (!arg1) {
66809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
66810     return 0;
66811   }
66812   {
66813     try {
66814       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
66815     } catch (std::out_of_range& e) {
66816       {
66817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66818       };
66819     } catch (std::exception& e) {
66820       {
66821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66822       };
66823     } catch (Dali::DaliException e) {
66824       {
66825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66826       };
66827     } catch (...) {
66828       {
66829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66830       };
66831     }
66832   }
66833
66834   jresult = (void *)result;
66835   return jresult;
66836 }
66837
66838
66839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
66840   void * jresult ;
66841   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
66842   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
66843   Dali::Toolkit::CheckBoxButton *result = 0 ;
66844
66845   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
66846   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
66847   if (!arg2) {
66848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
66849     return 0;
66850   }
66851   {
66852     try {
66853       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
66854     } catch (std::out_of_range& e) {
66855       {
66856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66857       };
66858     } catch (std::exception& e) {
66859       {
66860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66861       };
66862     } catch (Dali::DaliException e) {
66863       {
66864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66865       };
66866     } catch (...) {
66867       {
66868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66869       };
66870     }
66871   }
66872
66873   jresult = (void *)result;
66874   return jresult;
66875 }
66876
66877
66878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
66879   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
66880
66881   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
66882   {
66883     try {
66884       delete arg1;
66885     } catch (std::out_of_range& e) {
66886       {
66887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66888       };
66889     } catch (std::exception& e) {
66890       {
66891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66892       };
66893     } catch (Dali::DaliException e) {
66894       {
66895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66896       };
66897     } catch (...) {
66898       {
66899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66900       };
66901     }
66902   }
66903
66904 }
66905
66906
66907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
66908   void * jresult ;
66909   Dali::Toolkit::CheckBoxButton result;
66910
66911   {
66912     try {
66913       result = Dali::Toolkit::CheckBoxButton::New();
66914     } catch (std::out_of_range& e) {
66915       {
66916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66917       };
66918     } catch (std::exception& e) {
66919       {
66920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66921       };
66922     } catch (Dali::DaliException e) {
66923       {
66924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66925       };
66926     } catch (...) {
66927       {
66928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66929       };
66930     }
66931   }
66932
66933   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
66934   return jresult;
66935 }
66936
66937
66938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
66939   void * jresult ;
66940   Dali::BaseHandle arg1 ;
66941   Dali::BaseHandle *argp1 ;
66942   Dali::Toolkit::CheckBoxButton result;
66943
66944   argp1 = (Dali::BaseHandle *)jarg1;
66945   if (!argp1) {
66946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66947     return 0;
66948   }
66949   arg1 = *argp1;
66950   {
66951     try {
66952       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
66953     } catch (std::out_of_range& e) {
66954       {
66955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66956       };
66957     } catch (std::exception& e) {
66958       {
66959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66960       };
66961     } catch (Dali::DaliException e) {
66962       {
66963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66964       };
66965     } catch (...) {
66966       {
66967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66968       };
66969     }
66970   }
66971
66972   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
66973   return jresult;
66974 }
66975
66976
66977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
66978   int jresult ;
66979   int result;
66980
66981   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
66982   jresult = (int)result;
66983   return jresult;
66984 }
66985
66986
66987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
66988   int jresult ;
66989   int result;
66990
66991   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
66992   jresult = (int)result;
66993   return jresult;
66994 }
66995
66996
66997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
66998   int jresult ;
66999   int result;
67000
67001   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
67002   jresult = (int)result;
67003   return jresult;
67004 }
67005
67006
67007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
67008   int jresult ;
67009   int result;
67010
67011   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
67012   jresult = (int)result;
67013   return jresult;
67014 }
67015
67016
67017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
67018   int jresult ;
67019   int result;
67020
67021   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
67022   jresult = (int)result;
67023   return jresult;
67024 }
67025
67026
67027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
67028   void * jresult ;
67029   Dali::Toolkit::PushButton::Property *result = 0 ;
67030
67031   {
67032     try {
67033       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
67034     } catch (std::out_of_range& e) {
67035       {
67036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67037       };
67038     } catch (std::exception& e) {
67039       {
67040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67041       };
67042     } catch (Dali::DaliException e) {
67043       {
67044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67045       };
67046     } catch (...) {
67047       {
67048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67049       };
67050     }
67051   }
67052
67053   jresult = (void *)result;
67054   return jresult;
67055 }
67056
67057
67058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
67059   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
67060
67061   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
67062   {
67063     try {
67064       delete arg1;
67065     } catch (std::out_of_range& e) {
67066       {
67067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67068       };
67069     } catch (std::exception& e) {
67070       {
67071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67072       };
67073     } catch (Dali::DaliException e) {
67074       {
67075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67076       };
67077     } catch (...) {
67078       {
67079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67080       };
67081     }
67082   }
67083
67084 }
67085
67086
67087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
67088   void * jresult ;
67089   Dali::Toolkit::PushButton *result = 0 ;
67090
67091   {
67092     try {
67093       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
67094     } catch (std::out_of_range& e) {
67095       {
67096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67097       };
67098     } catch (std::exception& e) {
67099       {
67100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67101       };
67102     } catch (Dali::DaliException e) {
67103       {
67104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67105       };
67106     } catch (...) {
67107       {
67108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67109       };
67110     }
67111   }
67112
67113   jresult = (void *)result;
67114   return jresult;
67115 }
67116
67117
67118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
67119   void * jresult ;
67120   Dali::Toolkit::PushButton *arg1 = 0 ;
67121   Dali::Toolkit::PushButton *result = 0 ;
67122
67123   arg1 = (Dali::Toolkit::PushButton *)jarg1;
67124   if (!arg1) {
67125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
67126     return 0;
67127   }
67128   {
67129     try {
67130       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
67131     } catch (std::out_of_range& e) {
67132       {
67133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67134       };
67135     } catch (std::exception& e) {
67136       {
67137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67138       };
67139     } catch (Dali::DaliException e) {
67140       {
67141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67142       };
67143     } catch (...) {
67144       {
67145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67146       };
67147     }
67148   }
67149
67150   jresult = (void *)result;
67151   return jresult;
67152 }
67153
67154
67155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
67156   void * jresult ;
67157   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
67158   Dali::Toolkit::PushButton *arg2 = 0 ;
67159   Dali::Toolkit::PushButton *result = 0 ;
67160
67161   arg1 = (Dali::Toolkit::PushButton *)jarg1;
67162   arg2 = (Dali::Toolkit::PushButton *)jarg2;
67163   if (!arg2) {
67164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
67165     return 0;
67166   }
67167   {
67168     try {
67169       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
67170     } catch (std::out_of_range& e) {
67171       {
67172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67173       };
67174     } catch (std::exception& e) {
67175       {
67176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67177       };
67178     } catch (Dali::DaliException e) {
67179       {
67180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67181       };
67182     } catch (...) {
67183       {
67184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67185       };
67186     }
67187   }
67188
67189   jresult = (void *)result;
67190   return jresult;
67191 }
67192
67193
67194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
67195   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
67196
67197   arg1 = (Dali::Toolkit::PushButton *)jarg1;
67198   {
67199     try {
67200       delete arg1;
67201     } catch (std::out_of_range& e) {
67202       {
67203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67204       };
67205     } catch (std::exception& e) {
67206       {
67207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67208       };
67209     } catch (Dali::DaliException e) {
67210       {
67211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67212       };
67213     } catch (...) {
67214       {
67215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67216       };
67217     }
67218   }
67219
67220 }
67221
67222
67223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
67224   void * jresult ;
67225   Dali::Toolkit::PushButton result;
67226
67227   {
67228     try {
67229       result = Dali::Toolkit::PushButton::New();
67230     } catch (std::out_of_range& e) {
67231       {
67232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67233       };
67234     } catch (std::exception& e) {
67235       {
67236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67237       };
67238     } catch (Dali::DaliException e) {
67239       {
67240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67241       };
67242     } catch (...) {
67243       {
67244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67245       };
67246     }
67247   }
67248
67249   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
67250   return jresult;
67251 }
67252
67253
67254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
67255   void * jresult ;
67256   Dali::BaseHandle arg1 ;
67257   Dali::BaseHandle *argp1 ;
67258   Dali::Toolkit::PushButton result;
67259
67260   argp1 = (Dali::BaseHandle *)jarg1;
67261   if (!argp1) {
67262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67263     return 0;
67264   }
67265   arg1 = *argp1;
67266   {
67267     try {
67268       result = Dali::Toolkit::PushButton::DownCast(arg1);
67269     } catch (std::out_of_range& e) {
67270       {
67271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67272       };
67273     } catch (std::exception& e) {
67274       {
67275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67276       };
67277     } catch (Dali::DaliException e) {
67278       {
67279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67280       };
67281     } catch (...) {
67282       {
67283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67284       };
67285     }
67286   }
67287
67288   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
67289   return jresult;
67290 }
67291
67292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
67293   void * jresult ;
67294   Dali::Toolkit::RadioButton *result = 0 ;
67295
67296   {
67297     try {
67298       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
67299     } catch (std::out_of_range& e) {
67300       {
67301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67302       };
67303     } catch (std::exception& e) {
67304       {
67305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67306       };
67307     } catch (Dali::DaliException e) {
67308       {
67309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67310       };
67311     } catch (...) {
67312       {
67313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67314       };
67315     }
67316   }
67317
67318   jresult = (void *)result;
67319   return jresult;
67320 }
67321
67322
67323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
67324   void * jresult ;
67325   Dali::Toolkit::RadioButton *arg1 = 0 ;
67326   Dali::Toolkit::RadioButton *result = 0 ;
67327
67328   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
67329   if (!arg1) {
67330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
67331     return 0;
67332   }
67333   {
67334     try {
67335       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
67336     } catch (std::out_of_range& e) {
67337       {
67338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67339       };
67340     } catch (std::exception& e) {
67341       {
67342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67343       };
67344     } catch (Dali::DaliException e) {
67345       {
67346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67347       };
67348     } catch (...) {
67349       {
67350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67351       };
67352     }
67353   }
67354
67355   jresult = (void *)result;
67356   return jresult;
67357 }
67358
67359
67360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
67361   void * jresult ;
67362   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
67363   Dali::Toolkit::RadioButton *arg2 = 0 ;
67364   Dali::Toolkit::RadioButton *result = 0 ;
67365
67366   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
67367   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
67368   if (!arg2) {
67369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
67370     return 0;
67371   }
67372   {
67373     try {
67374       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
67375     } catch (std::out_of_range& e) {
67376       {
67377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67378       };
67379     } catch (std::exception& e) {
67380       {
67381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67382       };
67383     } catch (Dali::DaliException e) {
67384       {
67385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67386       };
67387     } catch (...) {
67388       {
67389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67390       };
67391     }
67392   }
67393
67394   jresult = (void *)result;
67395   return jresult;
67396 }
67397
67398
67399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
67400   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
67401
67402   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
67403   {
67404     try {
67405       delete arg1;
67406     } catch (std::out_of_range& e) {
67407       {
67408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67409       };
67410     } catch (std::exception& e) {
67411       {
67412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67413       };
67414     } catch (Dali::DaliException e) {
67415       {
67416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67417       };
67418     } catch (...) {
67419       {
67420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67421       };
67422     }
67423   }
67424
67425 }
67426
67427
67428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
67429   void * jresult ;
67430   Dali::Toolkit::RadioButton result;
67431
67432   {
67433     try {
67434       result = Dali::Toolkit::RadioButton::New();
67435     } catch (std::out_of_range& e) {
67436       {
67437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67438       };
67439     } catch (std::exception& e) {
67440       {
67441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67442       };
67443     } catch (Dali::DaliException e) {
67444       {
67445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67446       };
67447     } catch (...) {
67448       {
67449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67450       };
67451     }
67452   }
67453
67454   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
67455   return jresult;
67456 }
67457
67458
67459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
67460   void * jresult ;
67461   std::string *arg1 = 0 ;
67462   Dali::Toolkit::RadioButton result;
67463
67464   if (!jarg1) {
67465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67466     return 0;
67467   }
67468   std::string arg1_str(jarg1);
67469   arg1 = &arg1_str;
67470   {
67471     try {
67472       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
67473     } catch (std::out_of_range& e) {
67474       {
67475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67476       };
67477     } catch (std::exception& e) {
67478       {
67479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67480       };
67481     } catch (Dali::DaliException e) {
67482       {
67483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67484       };
67485     } catch (...) {
67486       {
67487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67488       };
67489     }
67490   }
67491
67492   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
67493
67494   //argout typemap for const std::string&
67495
67496   return jresult;
67497 }
67498
67499
67500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
67501   void * jresult ;
67502   Dali::BaseHandle arg1 ;
67503   Dali::BaseHandle *argp1 ;
67504   Dali::Toolkit::RadioButton result;
67505
67506   argp1 = (Dali::BaseHandle *)jarg1;
67507   if (!argp1) {
67508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67509     return 0;
67510   }
67511   arg1 = *argp1;
67512   {
67513     try {
67514       result = Dali::Toolkit::RadioButton::DownCast(arg1);
67515     } catch (std::out_of_range& e) {
67516       {
67517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67518       };
67519     } catch (std::exception& e) {
67520       {
67521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67522       };
67523     } catch (Dali::DaliException e) {
67524       {
67525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67526       };
67527     } catch (...) {
67528       {
67529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67530       };
67531     }
67532   }
67533
67534   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
67535   return jresult;
67536 }
67537
67538
67539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
67540   int jresult ;
67541   int result;
67542
67543   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
67544   jresult = (int)result;
67545   return jresult;
67546 }
67547
67548
67549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
67550   int jresult ;
67551   int result;
67552
67553   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
67554   jresult = (int)result;
67555   return jresult;
67556 }
67557
67558
67559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
67560   int jresult ;
67561   int result;
67562
67563   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
67564   jresult = (int)result;
67565   return jresult;
67566 }
67567
67568
67569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
67570   int jresult ;
67571   int result;
67572
67573   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
67574   jresult = (int)result;
67575   return jresult;
67576 }
67577
67578
67579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
67580   int jresult ;
67581   int result;
67582
67583   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
67584   jresult = (int)result;
67585   return jresult;
67586 }
67587
67588
67589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
67590   int jresult ;
67591   int result;
67592
67593   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
67594   jresult = (int)result;
67595   return jresult;
67596 }
67597
67598
67599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
67600   void * jresult ;
67601   Dali::Toolkit::FlexContainer::Property *result = 0 ;
67602
67603   {
67604     try {
67605       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
67606     } catch (std::out_of_range& e) {
67607       {
67608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67609       };
67610     } catch (std::exception& e) {
67611       {
67612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67613       };
67614     } catch (Dali::DaliException e) {
67615       {
67616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67617       };
67618     } catch (...) {
67619       {
67620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67621       };
67622     }
67623   }
67624
67625   jresult = (void *)result;
67626   return jresult;
67627 }
67628
67629
67630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
67631   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
67632
67633   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
67634   {
67635     try {
67636       delete arg1;
67637     } catch (std::out_of_range& e) {
67638       {
67639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67640       };
67641     } catch (std::exception& e) {
67642       {
67643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67644       };
67645     } catch (Dali::DaliException e) {
67646       {
67647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67648       };
67649     } catch (...) {
67650       {
67651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67652       };
67653     }
67654   }
67655
67656 }
67657
67658
67659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
67660   int jresult ;
67661   int result;
67662
67663   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
67664   jresult = (int)result;
67665   return jresult;
67666 }
67667
67668
67669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
67670   int jresult ;
67671   int result;
67672
67673   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
67674   jresult = (int)result;
67675   return jresult;
67676 }
67677
67678
67679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
67680   int jresult ;
67681   int result;
67682
67683   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
67684   jresult = (int)result;
67685   return jresult;
67686 }
67687
67688
67689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
67690   void * jresult ;
67691   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
67692
67693   {
67694     try {
67695       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
67696     } catch (std::out_of_range& e) {
67697       {
67698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67699       };
67700     } catch (std::exception& e) {
67701       {
67702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67703       };
67704     } catch (Dali::DaliException e) {
67705       {
67706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67707       };
67708     } catch (...) {
67709       {
67710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67711       };
67712     }
67713   }
67714
67715   jresult = (void *)result;
67716   return jresult;
67717 }
67718
67719
67720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
67721   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
67722
67723   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
67724   {
67725     try {
67726       delete arg1;
67727     } catch (std::out_of_range& e) {
67728       {
67729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67730       };
67731     } catch (std::exception& e) {
67732       {
67733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67734       };
67735     } catch (Dali::DaliException e) {
67736       {
67737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67738       };
67739     } catch (...) {
67740       {
67741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67742       };
67743     }
67744   }
67745
67746 }
67747
67748
67749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
67750   void * jresult ;
67751   Dali::Toolkit::FlexContainer *result = 0 ;
67752
67753   {
67754     try {
67755       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
67756     } catch (std::out_of_range& e) {
67757       {
67758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67759       };
67760     } catch (std::exception& e) {
67761       {
67762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67763       };
67764     } catch (Dali::DaliException e) {
67765       {
67766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67767       };
67768     } catch (...) {
67769       {
67770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67771       };
67772     }
67773   }
67774
67775   jresult = (void *)result;
67776   return jresult;
67777 }
67778
67779
67780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
67781   void * jresult ;
67782   Dali::Toolkit::FlexContainer *arg1 = 0 ;
67783   Dali::Toolkit::FlexContainer *result = 0 ;
67784
67785   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
67786   if (!arg1) {
67787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
67788     return 0;
67789   }
67790   {
67791     try {
67792       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
67793     } catch (std::out_of_range& e) {
67794       {
67795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67796       };
67797     } catch (std::exception& e) {
67798       {
67799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67800       };
67801     } catch (Dali::DaliException e) {
67802       {
67803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67804       };
67805     } catch (...) {
67806       {
67807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67808       };
67809     }
67810   }
67811
67812   jresult = (void *)result;
67813   return jresult;
67814 }
67815
67816
67817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
67818   void * jresult ;
67819   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
67820   Dali::Toolkit::FlexContainer *arg2 = 0 ;
67821   Dali::Toolkit::FlexContainer *result = 0 ;
67822
67823   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
67824   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
67825   if (!arg2) {
67826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
67827     return 0;
67828   }
67829   {
67830     try {
67831       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
67832     } catch (std::out_of_range& e) {
67833       {
67834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67835       };
67836     } catch (std::exception& e) {
67837       {
67838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67839       };
67840     } catch (Dali::DaliException e) {
67841       {
67842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67843       };
67844     } catch (...) {
67845       {
67846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67847       };
67848     }
67849   }
67850
67851   jresult = (void *)result;
67852   return jresult;
67853 }
67854
67855
67856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
67857   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
67858
67859   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
67860   {
67861     try {
67862       delete arg1;
67863     } catch (std::out_of_range& e) {
67864       {
67865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67866       };
67867     } catch (std::exception& e) {
67868       {
67869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67870       };
67871     } catch (Dali::DaliException e) {
67872       {
67873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67874       };
67875     } catch (...) {
67876       {
67877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67878       };
67879     }
67880   }
67881
67882 }
67883
67884
67885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
67886   void * jresult ;
67887   Dali::Toolkit::FlexContainer result;
67888
67889   {
67890     try {
67891       result = Dali::Toolkit::FlexContainer::New();
67892     } catch (std::out_of_range& e) {
67893       {
67894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67895       };
67896     } catch (std::exception& e) {
67897       {
67898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67899       };
67900     } catch (Dali::DaliException e) {
67901       {
67902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67903       };
67904     } catch (...) {
67905       {
67906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67907       };
67908     }
67909   }
67910
67911   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
67912   return jresult;
67913 }
67914
67915
67916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
67917   void * jresult ;
67918   Dali::BaseHandle arg1 ;
67919   Dali::BaseHandle *argp1 ;
67920   Dali::Toolkit::FlexContainer result;
67921
67922   argp1 = (Dali::BaseHandle *)jarg1;
67923   if (!argp1) {
67924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67925     return 0;
67926   }
67927   arg1 = *argp1;
67928   {
67929     try {
67930       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
67931     } catch (std::out_of_range& e) {
67932       {
67933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67934       };
67935     } catch (std::exception& e) {
67936       {
67937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67938       };
67939     } catch (Dali::DaliException e) {
67940       {
67941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67942       };
67943     } catch (...) {
67944       {
67945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67946       };
67947     }
67948   }
67949
67950   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
67951   return jresult;
67952 }
67953
67954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
67955   int jresult ;
67956   int result;
67957
67958   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
67959   jresult = (int)result;
67960   return jresult;
67961 }
67962
67963
67964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
67965   int jresult ;
67966   int result;
67967
67968   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
67969   jresult = (int)result;
67970   return jresult;
67971 }
67972
67973
67974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
67975   int jresult ;
67976   int result;
67977
67978   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
67979   jresult = (int)result;
67980   return jresult;
67981 }
67982
67983
67984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
67985   void * jresult ;
67986   Dali::Toolkit::ImageView::Property *result = 0 ;
67987
67988   {
67989     try {
67990       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
67991     } catch (std::out_of_range& e) {
67992       {
67993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67994       };
67995     } catch (std::exception& e) {
67996       {
67997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67998       };
67999     } catch (Dali::DaliException e) {
68000       {
68001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68002       };
68003     } catch (...) {
68004       {
68005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68006       };
68007     }
68008   }
68009
68010   jresult = (void *)result;
68011   return jresult;
68012 }
68013
68014
68015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
68016   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
68017
68018   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
68019   {
68020     try {
68021       delete arg1;
68022     } catch (std::out_of_range& e) {
68023       {
68024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68025       };
68026     } catch (std::exception& e) {
68027       {
68028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68029       };
68030     } catch (Dali::DaliException e) {
68031       {
68032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68033       };
68034     } catch (...) {
68035       {
68036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68037       };
68038     }
68039   }
68040
68041 }
68042
68043
68044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
68045   void * jresult ;
68046   Dali::Toolkit::ImageView *result = 0 ;
68047
68048   {
68049     try {
68050       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
68051     } catch (std::out_of_range& e) {
68052       {
68053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68054       };
68055     } catch (std::exception& e) {
68056       {
68057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68058       };
68059     } catch (Dali::DaliException e) {
68060       {
68061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68062       };
68063     } catch (...) {
68064       {
68065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68066       };
68067     }
68068   }
68069
68070   jresult = (void *)result;
68071   return jresult;
68072 }
68073
68074
68075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
68076   void * jresult ;
68077   Dali::Toolkit::ImageView result;
68078
68079   {
68080     try {
68081       result = Dali::Toolkit::ImageView::New();
68082     } catch (std::out_of_range& e) {
68083       {
68084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68085       };
68086     } catch (std::exception& e) {
68087       {
68088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68089       };
68090     } catch (Dali::DaliException e) {
68091       {
68092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68093       };
68094     } catch (...) {
68095       {
68096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68097       };
68098     }
68099   }
68100
68101   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
68102   return jresult;
68103 }
68104
68105
68106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
68107   void * jresult ;
68108   std::string *arg1 = 0 ;
68109   Dali::Toolkit::ImageView result;
68110
68111   if (!jarg1) {
68112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68113     return 0;
68114   }
68115   std::string arg1_str(jarg1);
68116   arg1 = &arg1_str;
68117   {
68118     try {
68119       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
68120     } catch (std::out_of_range& e) {
68121       {
68122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68123       };
68124     } catch (std::exception& e) {
68125       {
68126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68127       };
68128     } catch (Dali::DaliException e) {
68129       {
68130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68131       };
68132     } catch (...) {
68133       {
68134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68135       };
68136     }
68137   }
68138
68139   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
68140
68141   //argout typemap for const std::string&
68142
68143   return jresult;
68144 }
68145
68146
68147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
68148   void * jresult ;
68149   std::string *arg1 = 0 ;
68150   Dali::ImageDimensions arg2 ;
68151   Dali::ImageDimensions *argp2 ;
68152   Dali::Toolkit::ImageView result;
68153
68154   if (!jarg1) {
68155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68156     return 0;
68157   }
68158   std::string arg1_str(jarg1);
68159   arg1 = &arg1_str;
68160   argp2 = (Dali::ImageDimensions *)jarg2;
68161   if (!argp2) {
68162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
68163     return 0;
68164   }
68165   arg2 = *argp2;
68166   {
68167     try {
68168       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
68169     } catch (std::out_of_range& e) {
68170       {
68171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68172       };
68173     } catch (std::exception& e) {
68174       {
68175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68176       };
68177     } catch (Dali::DaliException e) {
68178       {
68179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68180       };
68181     } catch (...) {
68182       {
68183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68184       };
68185     }
68186   }
68187
68188   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
68189
68190   //argout typemap for const std::string&
68191
68192   return jresult;
68193 }
68194
68195
68196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
68197   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
68198
68199   arg1 = (Dali::Toolkit::ImageView *)jarg1;
68200   {
68201     try {
68202       delete arg1;
68203     } catch (std::out_of_range& e) {
68204       {
68205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68206       };
68207     } catch (std::exception& e) {
68208       {
68209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68210       };
68211     } catch (Dali::DaliException e) {
68212       {
68213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68214       };
68215     } catch (...) {
68216       {
68217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68218       };
68219     }
68220   }
68221
68222 }
68223
68224
68225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
68226   void * jresult ;
68227   Dali::Toolkit::ImageView *arg1 = 0 ;
68228   Dali::Toolkit::ImageView *result = 0 ;
68229
68230   arg1 = (Dali::Toolkit::ImageView *)jarg1;
68231   if (!arg1) {
68232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
68233     return 0;
68234   }
68235   {
68236     try {
68237       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
68238     } catch (std::out_of_range& e) {
68239       {
68240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68241       };
68242     } catch (std::exception& e) {
68243       {
68244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68245       };
68246     } catch (Dali::DaliException e) {
68247       {
68248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68249       };
68250     } catch (...) {
68251       {
68252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68253       };
68254     }
68255   }
68256
68257   jresult = (void *)result;
68258   return jresult;
68259 }
68260
68261
68262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
68263   void * jresult ;
68264   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
68265   Dali::Toolkit::ImageView *arg2 = 0 ;
68266   Dali::Toolkit::ImageView *result = 0 ;
68267
68268   arg1 = (Dali::Toolkit::ImageView *)jarg1;
68269   arg2 = (Dali::Toolkit::ImageView *)jarg2;
68270   if (!arg2) {
68271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
68272     return 0;
68273   }
68274   {
68275     try {
68276       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
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 = (void *)result;
68297   return jresult;
68298 }
68299
68300
68301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
68302   void * jresult ;
68303   Dali::BaseHandle arg1 ;
68304   Dali::BaseHandle *argp1 ;
68305   Dali::Toolkit::ImageView result;
68306
68307   argp1 = (Dali::BaseHandle *)jarg1;
68308   if (!argp1) {
68309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68310     return 0;
68311   }
68312   arg1 = *argp1;
68313   {
68314     try {
68315       result = Dali::Toolkit::ImageView::DownCast(arg1);
68316     } catch (std::out_of_range& e) {
68317       {
68318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68319       };
68320     } catch (std::exception& e) {
68321       {
68322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68323       };
68324     } catch (Dali::DaliException e) {
68325       {
68326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68327       };
68328     } catch (...) {
68329       {
68330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68331       };
68332     }
68333   }
68334
68335   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
68336   return jresult;
68337 }
68338
68339
68340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
68341   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
68342   std::string *arg2 = 0 ;
68343
68344   arg1 = (Dali::Toolkit::ImageView *)jarg1;
68345   if (!jarg2) {
68346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68347     return ;
68348   }
68349   std::string arg2_str(jarg2);
68350   arg2 = &arg2_str;
68351   {
68352     try {
68353       (arg1)->SetImage((std::string const &)*arg2);
68354     } catch (std::out_of_range& e) {
68355       {
68356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68357       };
68358     } catch (std::exception& e) {
68359       {
68360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68361       };
68362     } catch (Dali::DaliException e) {
68363       {
68364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68365       };
68366     } catch (...) {
68367       {
68368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68369       };
68370     }
68371   }
68372
68373
68374   //argout typemap for const std::string&
68375
68376 }
68377
68378
68379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
68380   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
68381   std::string *arg2 = 0 ;
68382   Dali::ImageDimensions arg3 ;
68383   Dali::ImageDimensions *argp3 ;
68384
68385   arg1 = (Dali::Toolkit::ImageView *)jarg1;
68386   if (!jarg2) {
68387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68388     return ;
68389   }
68390   std::string arg2_str(jarg2);
68391   arg2 = &arg2_str;
68392   argp3 = (Dali::ImageDimensions *)jarg3;
68393   if (!argp3) {
68394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
68395     return ;
68396   }
68397   arg3 = *argp3;
68398   {
68399     try {
68400       (arg1)->SetImage((std::string const &)*arg2,arg3);
68401     } catch (std::out_of_range& e) {
68402       {
68403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68404       };
68405     } catch (std::exception& e) {
68406       {
68407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68408       };
68409     } catch (Dali::DaliException e) {
68410       {
68411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68412       };
68413     } catch (...) {
68414       {
68415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68416       };
68417     }
68418   }
68419
68420
68421   //argout typemap for const std::string&
68422
68423 }
68424
68425
68426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
68427   int jresult ;
68428   int result;
68429
68430   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
68431   jresult = (int)result;
68432   return jresult;
68433 }
68434
68435
68436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
68437   int jresult ;
68438   int result;
68439
68440   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
68441   jresult = (int)result;
68442   return jresult;
68443 }
68444
68445
68446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
68447   int jresult ;
68448   int result;
68449
68450   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
68451   jresult = (int)result;
68452   return jresult;
68453 }
68454
68455
68456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
68457   int jresult ;
68458   int result;
68459
68460   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
68461   jresult = (int)result;
68462   return jresult;
68463 }
68464
68465
68466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
68467   int jresult ;
68468   int result;
68469
68470   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
68471   jresult = (int)result;
68472   return jresult;
68473 }
68474
68475
68476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
68477   int jresult ;
68478   int result;
68479
68480   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
68481   jresult = (int)result;
68482   return jresult;
68483 }
68484
68485
68486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
68487   int jresult ;
68488   int result;
68489
68490   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
68491   jresult = (int)result;
68492   return jresult;
68493 }
68494
68495
68496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
68497   int jresult ;
68498   int result;
68499
68500   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
68501   jresult = (int)result;
68502   return jresult;
68503 }
68504
68505
68506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
68507   void * jresult ;
68508   Dali::Toolkit::Model3dView::Property *result = 0 ;
68509
68510   {
68511     try {
68512       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
68513     } catch (std::out_of_range& e) {
68514       {
68515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68516       };
68517     } catch (std::exception& e) {
68518       {
68519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68520       };
68521     } catch (Dali::DaliException e) {
68522       {
68523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68524       };
68525     } catch (...) {
68526       {
68527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68528       };
68529     }
68530   }
68531
68532   jresult = (void *)result;
68533   return jresult;
68534 }
68535
68536
68537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
68538   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
68539
68540   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
68541   {
68542     try {
68543       delete arg1;
68544     } catch (std::out_of_range& e) {
68545       {
68546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68547       };
68548     } catch (std::exception& e) {
68549       {
68550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68551       };
68552     } catch (Dali::DaliException e) {
68553       {
68554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68555       };
68556     } catch (...) {
68557       {
68558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68559       };
68560     }
68561   }
68562
68563 }
68564
68565
68566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
68567   void * jresult ;
68568   Dali::Toolkit::Model3dView result;
68569
68570   {
68571     try {
68572       result = Dali::Toolkit::Model3dView::New();
68573     } catch (std::out_of_range& e) {
68574       {
68575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68576       };
68577     } catch (std::exception& e) {
68578       {
68579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68580       };
68581     } catch (Dali::DaliException e) {
68582       {
68583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68584       };
68585     } catch (...) {
68586       {
68587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68588       };
68589     }
68590   }
68591
68592   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
68593   return jresult;
68594 }
68595
68596
68597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
68598   void * jresult ;
68599   std::string *arg1 = 0 ;
68600   std::string *arg2 = 0 ;
68601   std::string *arg3 = 0 ;
68602   Dali::Toolkit::Model3dView result;
68603
68604   if (!jarg1) {
68605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68606     return 0;
68607   }
68608   std::string arg1_str(jarg1);
68609   arg1 = &arg1_str;
68610   if (!jarg2) {
68611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68612     return 0;
68613   }
68614   std::string arg2_str(jarg2);
68615   arg2 = &arg2_str;
68616   if (!jarg3) {
68617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68618     return 0;
68619   }
68620   std::string arg3_str(jarg3);
68621   arg3 = &arg3_str;
68622   {
68623     try {
68624       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
68625     } catch (std::out_of_range& e) {
68626       {
68627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68628       };
68629     } catch (std::exception& e) {
68630       {
68631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68632       };
68633     } catch (Dali::DaliException e) {
68634       {
68635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68636       };
68637     } catch (...) {
68638       {
68639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68640       };
68641     }
68642   }
68643
68644   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
68645
68646   //argout typemap for const std::string&
68647
68648
68649   //argout typemap for const std::string&
68650
68651
68652   //argout typemap for const std::string&
68653
68654   return jresult;
68655 }
68656
68657
68658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
68659   void * jresult ;
68660   Dali::Toolkit::Model3dView *result = 0 ;
68661
68662   {
68663     try {
68664       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
68665     } catch (std::out_of_range& e) {
68666       {
68667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68668       };
68669     } catch (std::exception& e) {
68670       {
68671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68672       };
68673     } catch (Dali::DaliException e) {
68674       {
68675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68676       };
68677     } catch (...) {
68678       {
68679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68680       };
68681     }
68682   }
68683
68684   jresult = (void *)result;
68685   return jresult;
68686 }
68687
68688
68689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
68690   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
68691
68692   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
68693   {
68694     try {
68695       delete arg1;
68696     } catch (std::out_of_range& e) {
68697       {
68698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68699       };
68700     } catch (std::exception& e) {
68701       {
68702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68703       };
68704     } catch (Dali::DaliException e) {
68705       {
68706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68707       };
68708     } catch (...) {
68709       {
68710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68711       };
68712     }
68713   }
68714
68715 }
68716
68717
68718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
68719   void * jresult ;
68720   Dali::Toolkit::Model3dView *arg1 = 0 ;
68721   Dali::Toolkit::Model3dView *result = 0 ;
68722
68723   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
68724   if (!arg1) {
68725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
68726     return 0;
68727   }
68728   {
68729     try {
68730       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
68731     } catch (std::out_of_range& e) {
68732       {
68733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68734       };
68735     } catch (std::exception& e) {
68736       {
68737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68738       };
68739     } catch (Dali::DaliException e) {
68740       {
68741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68742       };
68743     } catch (...) {
68744       {
68745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68746       };
68747     }
68748   }
68749
68750   jresult = (void *)result;
68751   return jresult;
68752 }
68753
68754
68755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
68756   void * jresult ;
68757   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
68758   Dali::Toolkit::Model3dView *arg2 = 0 ;
68759   Dali::Toolkit::Model3dView *result = 0 ;
68760
68761   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
68762   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
68763   if (!arg2) {
68764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
68765     return 0;
68766   }
68767   {
68768     try {
68769       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
68770     } catch (std::out_of_range& e) {
68771       {
68772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68773       };
68774     } catch (std::exception& e) {
68775       {
68776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68777       };
68778     } catch (Dali::DaliException e) {
68779       {
68780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68781       };
68782     } catch (...) {
68783       {
68784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68785       };
68786     }
68787   }
68788
68789   jresult = (void *)result;
68790   return jresult;
68791 }
68792
68793
68794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
68795   void * jresult ;
68796   Dali::BaseHandle arg1 ;
68797   Dali::BaseHandle *argp1 ;
68798   Dali::Toolkit::Model3dView result;
68799
68800   argp1 = (Dali::BaseHandle *)jarg1;
68801   if (!argp1) {
68802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68803     return 0;
68804   }
68805   arg1 = *argp1;
68806   {
68807     try {
68808       result = Dali::Toolkit::Model3dView::DownCast(arg1);
68809     } catch (std::out_of_range& e) {
68810       {
68811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68812       };
68813     } catch (std::exception& e) {
68814       {
68815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68816       };
68817     } catch (Dali::DaliException e) {
68818       {
68819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68820       };
68821     } catch (...) {
68822       {
68823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68824       };
68825     }
68826   }
68827
68828   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
68829   return jresult;
68830 }
68831
68832
68833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
68834   int jresult ;
68835   int result;
68836
68837   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
68838   jresult = (int)result;
68839   return jresult;
68840 }
68841
68842
68843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
68844   int jresult ;
68845   int result;
68846
68847   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
68848   jresult = (int)result;
68849   return jresult;
68850 }
68851
68852
68853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
68854   int jresult ;
68855   int result;
68856
68857   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
68858   jresult = (int)result;
68859   return jresult;
68860 }
68861
68862
68863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
68864   int jresult ;
68865   int result;
68866
68867   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
68868   jresult = (int)result;
68869   return jresult;
68870 }
68871
68872
68873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
68874   int jresult ;
68875   int result;
68876
68877   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
68878   jresult = (int)result;
68879   return jresult;
68880 }
68881
68882
68883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
68884   int jresult ;
68885   int result;
68886
68887   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
68888   jresult = (int)result;
68889   return jresult;
68890 }
68891
68892
68893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
68894   int jresult ;
68895   int result;
68896
68897   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
68898   jresult = (int)result;
68899   return jresult;
68900 }
68901
68902
68903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
68904   int jresult ;
68905   int result;
68906
68907   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
68908   jresult = (int)result;
68909   return jresult;
68910 }
68911
68912
68913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
68914   int jresult ;
68915   int result;
68916
68917   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
68918   jresult = (int)result;
68919   return jresult;
68920 }
68921
68922
68923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
68924   void * jresult ;
68925   Dali::Toolkit::ScrollBar::Property *result = 0 ;
68926
68927   {
68928     try {
68929       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
68930     } catch (std::out_of_range& e) {
68931       {
68932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68933       };
68934     } catch (std::exception& e) {
68935       {
68936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68937       };
68938     } catch (Dali::DaliException e) {
68939       {
68940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68941       };
68942     } catch (...) {
68943       {
68944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68945       };
68946     }
68947   }
68948
68949   jresult = (void *)result;
68950   return jresult;
68951 }
68952
68953
68954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
68955   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
68956
68957   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
68958   {
68959     try {
68960       delete arg1;
68961     } catch (std::out_of_range& e) {
68962       {
68963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68964       };
68965     } catch (std::exception& e) {
68966       {
68967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68968       };
68969     } catch (Dali::DaliException e) {
68970       {
68971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68972       };
68973     } catch (...) {
68974       {
68975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68976       };
68977     }
68978   }
68979
68980 }
68981
68982
68983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
68984   void * jresult ;
68985   Dali::Toolkit::ScrollBar *result = 0 ;
68986
68987   {
68988     try {
68989       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
68990     } catch (std::out_of_range& e) {
68991       {
68992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68993       };
68994     } catch (std::exception& e) {
68995       {
68996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68997       };
68998     } catch (Dali::DaliException e) {
68999       {
69000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69001       };
69002     } catch (...) {
69003       {
69004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69005       };
69006     }
69007   }
69008
69009   jresult = (void *)result;
69010   return jresult;
69011 }
69012
69013
69014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
69015   void * jresult ;
69016   Dali::Toolkit::ScrollBar *arg1 = 0 ;
69017   Dali::Toolkit::ScrollBar *result = 0 ;
69018
69019   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69020   if (!arg1) {
69021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
69022     return 0;
69023   }
69024   {
69025     try {
69026       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
69027     } catch (std::out_of_range& e) {
69028       {
69029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69030       };
69031     } catch (std::exception& e) {
69032       {
69033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69034       };
69035     } catch (Dali::DaliException e) {
69036       {
69037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69038       };
69039     } catch (...) {
69040       {
69041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69042       };
69043     }
69044   }
69045
69046   jresult = (void *)result;
69047   return jresult;
69048 }
69049
69050
69051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
69052   void * jresult ;
69053   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69054   Dali::Toolkit::ScrollBar *arg2 = 0 ;
69055   Dali::Toolkit::ScrollBar *result = 0 ;
69056
69057   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69058   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
69059   if (!arg2) {
69060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
69061     return 0;
69062   }
69063   {
69064     try {
69065       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
69066     } catch (std::out_of_range& e) {
69067       {
69068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69069       };
69070     } catch (std::exception& e) {
69071       {
69072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69073       };
69074     } catch (Dali::DaliException e) {
69075       {
69076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69077       };
69078     } catch (...) {
69079       {
69080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69081       };
69082     }
69083   }
69084
69085   jresult = (void *)result;
69086   return jresult;
69087 }
69088
69089
69090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
69091   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69092
69093   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69094   {
69095     try {
69096       delete arg1;
69097     } catch (std::out_of_range& e) {
69098       {
69099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69100       };
69101     } catch (std::exception& e) {
69102       {
69103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69104       };
69105     } catch (Dali::DaliException e) {
69106       {
69107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69108       };
69109     } catch (...) {
69110       {
69111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69112       };
69113     }
69114   }
69115
69116 }
69117
69118
69119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
69120   void * jresult ;
69121   Dali::Toolkit::ScrollBar::Direction arg1 ;
69122   Dali::Toolkit::ScrollBar result;
69123
69124   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
69125   {
69126     try {
69127       result = Dali::Toolkit::ScrollBar::New(arg1);
69128     } catch (std::out_of_range& e) {
69129       {
69130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69131       };
69132     } catch (std::exception& e) {
69133       {
69134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69135       };
69136     } catch (Dali::DaliException e) {
69137       {
69138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69139       };
69140     } catch (...) {
69141       {
69142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69143       };
69144     }
69145   }
69146
69147   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
69148   return jresult;
69149 }
69150
69151
69152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
69153   void * jresult ;
69154   Dali::Toolkit::ScrollBar result;
69155
69156   {
69157     try {
69158       result = Dali::Toolkit::ScrollBar::New();
69159     } catch (std::out_of_range& e) {
69160       {
69161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69162       };
69163     } catch (std::exception& e) {
69164       {
69165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69166       };
69167     } catch (Dali::DaliException e) {
69168       {
69169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69170       };
69171     } catch (...) {
69172       {
69173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69174       };
69175     }
69176   }
69177
69178   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
69179   return jresult;
69180 }
69181
69182
69183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
69184   void * jresult ;
69185   Dali::BaseHandle arg1 ;
69186   Dali::BaseHandle *argp1 ;
69187   Dali::Toolkit::ScrollBar result;
69188
69189   argp1 = (Dali::BaseHandle *)jarg1;
69190   if (!argp1) {
69191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69192     return 0;
69193   }
69194   arg1 = *argp1;
69195   {
69196     try {
69197       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
69198     } catch (std::out_of_range& e) {
69199       {
69200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69201       };
69202     } catch (std::exception& e) {
69203       {
69204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69205       };
69206     } catch (Dali::DaliException e) {
69207       {
69208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69209       };
69210     } catch (...) {
69211       {
69212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69213       };
69214     }
69215   }
69216
69217   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
69218   return jresult;
69219 }
69220
69221
69222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
69223   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69224   Dali::Handle arg2 ;
69225   Dali::Property::Index arg3 ;
69226   Dali::Property::Index arg4 ;
69227   Dali::Property::Index arg5 ;
69228   Dali::Property::Index arg6 ;
69229   Dali::Handle *argp2 ;
69230
69231   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69232   argp2 = (Dali::Handle *)jarg2;
69233   if (!argp2) {
69234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
69235     return ;
69236   }
69237   arg2 = *argp2;
69238   arg3 = (Dali::Property::Index)jarg3;
69239   arg4 = (Dali::Property::Index)jarg4;
69240   arg5 = (Dali::Property::Index)jarg5;
69241   arg6 = (Dali::Property::Index)jarg6;
69242   {
69243     try {
69244       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
69245     } catch (std::out_of_range& e) {
69246       {
69247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69248       };
69249     } catch (std::exception& e) {
69250       {
69251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69252       };
69253     } catch (Dali::DaliException e) {
69254       {
69255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69256       };
69257     } catch (...) {
69258       {
69259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69260       };
69261     }
69262   }
69263
69264 }
69265
69266
69267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
69268   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69269   Dali::Actor arg2 ;
69270   Dali::Actor *argp2 ;
69271
69272   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69273   argp2 = (Dali::Actor *)jarg2;
69274   if (!argp2) {
69275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69276     return ;
69277   }
69278   arg2 = *argp2;
69279   {
69280     try {
69281       (arg1)->SetScrollIndicator(arg2);
69282     } catch (std::out_of_range& e) {
69283       {
69284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69285       };
69286     } catch (std::exception& e) {
69287       {
69288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69289       };
69290     } catch (Dali::DaliException e) {
69291       {
69292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69293       };
69294     } catch (...) {
69295       {
69296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69297       };
69298     }
69299   }
69300
69301 }
69302
69303
69304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
69305   void * jresult ;
69306   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69307   Dali::Actor result;
69308
69309   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69310   {
69311     try {
69312       result = (arg1)->GetScrollIndicator();
69313     } catch (std::out_of_range& e) {
69314       {
69315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69316       };
69317     } catch (std::exception& e) {
69318       {
69319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69320       };
69321     } catch (Dali::DaliException e) {
69322       {
69323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69324       };
69325     } catch (...) {
69326       {
69327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69328       };
69329     }
69330   }
69331
69332   jresult = new Dali::Actor((const Dali::Actor &)result);
69333   return jresult;
69334 }
69335
69336
69337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
69338   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69339   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
69340
69341   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69342   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
69343   if (!arg2) {
69344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
69345     return ;
69346   }
69347   {
69348     try {
69349       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
69350     } catch (std::out_of_range& e) {
69351       {
69352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69353       };
69354     } catch (std::exception& e) {
69355       {
69356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69357       };
69358     } catch (Dali::DaliException e) {
69359       {
69360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69361       };
69362     } catch (...) {
69363       {
69364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69365       };
69366     }
69367   }
69368
69369 }
69370
69371
69372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
69373   void * jresult ;
69374   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69375
69376   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69377   {
69378     try {
69379       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()));
69380     } catch (std::out_of_range& e) {
69381       {
69382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69383       };
69384     } catch (std::exception& e) {
69385       {
69386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69387       };
69388     } catch (...) {
69389       {
69390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69391       };
69392     }
69393   }
69394   return jresult;
69395 }
69396
69397
69398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
69399   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69400   Dali::Toolkit::ScrollBar::Direction arg2 ;
69401
69402   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69403   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
69404   {
69405     try {
69406       (arg1)->SetScrollDirection(arg2);
69407     } catch (std::out_of_range& e) {
69408       {
69409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69410       };
69411     } catch (std::exception& e) {
69412       {
69413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69414       };
69415     } catch (Dali::DaliException e) {
69416       {
69417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69418       };
69419     } catch (...) {
69420       {
69421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69422       };
69423     }
69424   }
69425
69426 }
69427
69428
69429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
69430   int jresult ;
69431   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69432   Dali::Toolkit::ScrollBar::Direction result;
69433
69434   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69435   {
69436     try {
69437       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
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 = (int)result;
69458   return jresult;
69459 }
69460
69461
69462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
69463   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69464   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
69465
69466   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69467   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
69468   {
69469     try {
69470       (arg1)->SetIndicatorHeightPolicy(arg2);
69471     } catch (std::out_of_range& e) {
69472       {
69473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69474       };
69475     } catch (std::exception& e) {
69476       {
69477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69478       };
69479     } catch (Dali::DaliException e) {
69480       {
69481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69482       };
69483     } catch (...) {
69484       {
69485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69486       };
69487     }
69488   }
69489
69490 }
69491
69492
69493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
69494   int jresult ;
69495   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69496   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
69497
69498   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69499   {
69500     try {
69501       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
69502     } catch (std::out_of_range& e) {
69503       {
69504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69505       };
69506     } catch (std::exception& e) {
69507       {
69508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69509       };
69510     } catch (Dali::DaliException e) {
69511       {
69512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69513       };
69514     } catch (...) {
69515       {
69516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69517       };
69518     }
69519   }
69520
69521   jresult = (int)result;
69522   return jresult;
69523 }
69524
69525
69526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
69527   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69528   float arg2 ;
69529
69530   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69531   arg2 = (float)jarg2;
69532   {
69533     try {
69534       (arg1)->SetIndicatorFixedHeight(arg2);
69535     } catch (std::out_of_range& e) {
69536       {
69537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69538       };
69539     } catch (std::exception& e) {
69540       {
69541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69542       };
69543     } catch (Dali::DaliException e) {
69544       {
69545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69546       };
69547     } catch (...) {
69548       {
69549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69550       };
69551     }
69552   }
69553
69554 }
69555
69556
69557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
69558   float jresult ;
69559   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69560   float result;
69561
69562   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69563   {
69564     try {
69565       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
69566     } catch (std::out_of_range& e) {
69567       {
69568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69569       };
69570     } catch (std::exception& e) {
69571       {
69572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69573       };
69574     } catch (Dali::DaliException e) {
69575       {
69576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69577       };
69578     } catch (...) {
69579       {
69580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69581       };
69582     }
69583   }
69584
69585   jresult = result;
69586   return jresult;
69587 }
69588
69589
69590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
69591   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69592   float arg2 ;
69593
69594   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69595   arg2 = (float)jarg2;
69596   {
69597     try {
69598       (arg1)->SetIndicatorShowDuration(arg2);
69599     } catch (std::out_of_range& e) {
69600       {
69601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69602       };
69603     } catch (std::exception& e) {
69604       {
69605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69606       };
69607     } catch (Dali::DaliException e) {
69608       {
69609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69610       };
69611     } catch (...) {
69612       {
69613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69614       };
69615     }
69616   }
69617
69618 }
69619
69620
69621 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
69622   float jresult ;
69623   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69624   float result;
69625
69626   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69627   {
69628     try {
69629       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
69630     } catch (std::out_of_range& e) {
69631       {
69632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69633       };
69634     } catch (std::exception& e) {
69635       {
69636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69637       };
69638     } catch (Dali::DaliException e) {
69639       {
69640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69641       };
69642     } catch (...) {
69643       {
69644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69645       };
69646     }
69647   }
69648
69649   jresult = result;
69650   return jresult;
69651 }
69652
69653
69654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
69655   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69656   float arg2 ;
69657
69658   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69659   arg2 = (float)jarg2;
69660   {
69661     try {
69662       (arg1)->SetIndicatorHideDuration(arg2);
69663     } catch (std::out_of_range& e) {
69664       {
69665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69666       };
69667     } catch (std::exception& e) {
69668       {
69669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69670       };
69671     } catch (Dali::DaliException e) {
69672       {
69673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69674       };
69675     } catch (...) {
69676       {
69677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69678       };
69679     }
69680   }
69681
69682 }
69683
69684
69685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
69686   float jresult ;
69687   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69688   float result;
69689
69690   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69691   {
69692     try {
69693       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
69694     } catch (std::out_of_range& e) {
69695       {
69696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69697       };
69698     } catch (std::exception& e) {
69699       {
69700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69701       };
69702     } catch (Dali::DaliException e) {
69703       {
69704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69705       };
69706     } catch (...) {
69707       {
69708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69709       };
69710     }
69711   }
69712
69713   jresult = result;
69714   return jresult;
69715 }
69716
69717
69718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
69719   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69720
69721   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69722   {
69723     try {
69724       (arg1)->ShowIndicator();
69725     } catch (std::out_of_range& e) {
69726       {
69727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69728       };
69729     } catch (std::exception& e) {
69730       {
69731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69732       };
69733     } catch (Dali::DaliException e) {
69734       {
69735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69736       };
69737     } catch (...) {
69738       {
69739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69740       };
69741     }
69742   }
69743
69744 }
69745
69746
69747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
69748   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69749
69750   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69751   {
69752     try {
69753       (arg1)->HideIndicator();
69754     } catch (std::out_of_range& e) {
69755       {
69756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69757       };
69758     } catch (std::exception& e) {
69759       {
69760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69761       };
69762     } catch (Dali::DaliException e) {
69763       {
69764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69765       };
69766     } catch (...) {
69767       {
69768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69769       };
69770     }
69771   }
69772
69773 }
69774
69775
69776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
69777   void * jresult ;
69778   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69779   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
69780
69781   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69782   {
69783     try {
69784       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
69785     } catch (std::out_of_range& e) {
69786       {
69787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69788       };
69789     } catch (std::exception& e) {
69790       {
69791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69792       };
69793     } catch (Dali::DaliException e) {
69794       {
69795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69796       };
69797     } catch (...) {
69798       {
69799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69800       };
69801     }
69802   }
69803
69804   jresult = (void *)result;
69805   return jresult;
69806 }
69807
69808
69809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
69810   void * jresult ;
69811   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69812   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
69813
69814   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69815   {
69816     try {
69817       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
69818     } catch (std::out_of_range& e) {
69819       {
69820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69821       };
69822     } catch (std::exception& e) {
69823       {
69824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69825       };
69826     } catch (Dali::DaliException e) {
69827       {
69828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69829       };
69830     } catch (...) {
69831       {
69832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69833       };
69834     }
69835   }
69836
69837   jresult = (void *)result;
69838   return jresult;
69839 }
69840
69841
69842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
69843   int jresult ;
69844   int result;
69845
69846   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
69847   jresult = (int)result;
69848   return jresult;
69849 }
69850
69851
69852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
69853   int jresult ;
69854   int result;
69855
69856   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
69857   jresult = (int)result;
69858   return jresult;
69859 }
69860
69861
69862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
69863   int jresult ;
69864   int result;
69865
69866   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
69867   jresult = (int)result;
69868   return jresult;
69869 }
69870
69871
69872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
69873   int jresult ;
69874   int result;
69875
69876   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
69877   jresult = (int)result;
69878   return jresult;
69879 }
69880
69881
69882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
69883   int jresult ;
69884   int result;
69885
69886   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
69887   jresult = (int)result;
69888   return jresult;
69889 }
69890
69891
69892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
69893   int jresult ;
69894   int result;
69895
69896   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
69897   jresult = (int)result;
69898   return jresult;
69899 }
69900
69901
69902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
69903   int jresult ;
69904   int result;
69905
69906   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
69907   jresult = (int)result;
69908   return jresult;
69909 }
69910
69911
69912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
69913   int jresult ;
69914   int result;
69915
69916   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
69917   jresult = (int)result;
69918   return jresult;
69919 }
69920
69921
69922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
69923   int jresult ;
69924   int result;
69925
69926   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
69927   jresult = (int)result;
69928   return jresult;
69929 }
69930
69931
69932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
69933   int jresult ;
69934   int result;
69935
69936   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
69937   jresult = (int)result;
69938   return jresult;
69939 }
69940
69941
69942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
69943   int jresult ;
69944   int result;
69945
69946   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
69947   jresult = (int)result;
69948   return jresult;
69949 }
69950
69951
69952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
69953   int jresult ;
69954   int result;
69955
69956   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
69957   jresult = (int)result;
69958   return jresult;
69959 }
69960
69961
69962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
69963   int jresult ;
69964   int result;
69965
69966   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
69967   jresult = (int)result;
69968   return jresult;
69969 }
69970
69971
69972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
69973   int jresult ;
69974   int result;
69975
69976   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
69977   jresult = (int)result;
69978   return jresult;
69979 }
69980
69981
69982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
69983   void * jresult ;
69984   Dali::Toolkit::Scrollable::Property *result = 0 ;
69985
69986   {
69987     try {
69988       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
69989     } catch (std::out_of_range& e) {
69990       {
69991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69992       };
69993     } catch (std::exception& e) {
69994       {
69995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69996       };
69997     } catch (Dali::DaliException e) {
69998       {
69999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70000       };
70001     } catch (...) {
70002       {
70003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70004       };
70005     }
70006   }
70007
70008   jresult = (void *)result;
70009   return jresult;
70010 }
70011
70012
70013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
70014   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
70015
70016   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
70017   {
70018     try {
70019       delete arg1;
70020     } catch (std::out_of_range& e) {
70021       {
70022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70023       };
70024     } catch (std::exception& e) {
70025       {
70026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70027       };
70028     } catch (Dali::DaliException e) {
70029       {
70030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70031       };
70032     } catch (...) {
70033       {
70034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70035       };
70036     }
70037   }
70038
70039 }
70040
70041
70042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
70043   void * jresult ;
70044   Dali::Toolkit::Scrollable *result = 0 ;
70045
70046   {
70047     try {
70048       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
70049     } catch (std::out_of_range& e) {
70050       {
70051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70052       };
70053     } catch (std::exception& e) {
70054       {
70055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70056       };
70057     } catch (Dali::DaliException e) {
70058       {
70059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70060       };
70061     } catch (...) {
70062       {
70063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70064       };
70065     }
70066   }
70067
70068   jresult = (void *)result;
70069   return jresult;
70070 }
70071
70072
70073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
70074   void * jresult ;
70075   Dali::Toolkit::Scrollable *arg1 = 0 ;
70076   Dali::Toolkit::Scrollable *result = 0 ;
70077
70078   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70079   if (!arg1) {
70080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
70081     return 0;
70082   }
70083   {
70084     try {
70085       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
70086     } catch (std::out_of_range& e) {
70087       {
70088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70089       };
70090     } catch (std::exception& e) {
70091       {
70092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70093       };
70094     } catch (Dali::DaliException e) {
70095       {
70096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70097       };
70098     } catch (...) {
70099       {
70100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70101       };
70102     }
70103   }
70104
70105   jresult = (void *)result;
70106   return jresult;
70107 }
70108
70109
70110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
70111   void * jresult ;
70112   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
70113   Dali::Toolkit::Scrollable *arg2 = 0 ;
70114   Dali::Toolkit::Scrollable *result = 0 ;
70115
70116   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70117   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
70118   if (!arg2) {
70119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
70120     return 0;
70121   }
70122   {
70123     try {
70124       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
70125     } catch (std::out_of_range& e) {
70126       {
70127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70128       };
70129     } catch (std::exception& e) {
70130       {
70131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70132       };
70133     } catch (Dali::DaliException e) {
70134       {
70135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70136       };
70137     } catch (...) {
70138       {
70139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70140       };
70141     }
70142   }
70143
70144   jresult = (void *)result;
70145   return jresult;
70146 }
70147
70148
70149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
70150   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
70151
70152   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70153   {
70154     try {
70155       delete arg1;
70156     } catch (std::out_of_range& e) {
70157       {
70158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70159       };
70160     } catch (std::exception& e) {
70161       {
70162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70163       };
70164     } catch (Dali::DaliException e) {
70165       {
70166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70167       };
70168     } catch (...) {
70169       {
70170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70171       };
70172     }
70173   }
70174
70175 }
70176
70177
70178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
70179   void * jresult ;
70180   Dali::BaseHandle arg1 ;
70181   Dali::BaseHandle *argp1 ;
70182   Dali::Toolkit::Scrollable result;
70183
70184   argp1 = (Dali::BaseHandle *)jarg1;
70185   if (!argp1) {
70186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70187     return 0;
70188   }
70189   arg1 = *argp1;
70190   {
70191     try {
70192       result = Dali::Toolkit::Scrollable::DownCast(arg1);
70193     } catch (std::out_of_range& e) {
70194       {
70195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70196       };
70197     } catch (std::exception& e) {
70198       {
70199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70200       };
70201     } catch (Dali::DaliException e) {
70202       {
70203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70204       };
70205     } catch (...) {
70206       {
70207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70208       };
70209     }
70210   }
70211
70212   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
70213   return jresult;
70214 }
70215
70216
70217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
70218   unsigned int jresult ;
70219   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
70220   bool result;
70221
70222   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70223   {
70224     try {
70225       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
70226     } catch (std::out_of_range& e) {
70227       {
70228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70229       };
70230     } catch (std::exception& e) {
70231       {
70232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70233       };
70234     } catch (Dali::DaliException e) {
70235       {
70236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70237       };
70238     } catch (...) {
70239       {
70240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70241       };
70242     }
70243   }
70244
70245   jresult = result;
70246   return jresult;
70247 }
70248
70249
70250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
70251   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
70252   bool arg2 ;
70253
70254   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70255   arg2 = jarg2 ? true : false;
70256   {
70257     try {
70258       (arg1)->SetOvershootEnabled(arg2);
70259     } catch (std::out_of_range& e) {
70260       {
70261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70262       };
70263     } catch (std::exception& e) {
70264       {
70265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70266       };
70267     } catch (Dali::DaliException e) {
70268       {
70269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70270       };
70271     } catch (...) {
70272       {
70273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70274       };
70275     }
70276   }
70277
70278 }
70279
70280
70281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
70282   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
70283   Dali::Vector4 *arg2 = 0 ;
70284
70285   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70286   arg2 = (Dali::Vector4 *)jarg2;
70287   if (!arg2) {
70288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
70289     return ;
70290   }
70291   {
70292     try {
70293       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
70294     } catch (std::out_of_range& e) {
70295       {
70296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70297       };
70298     } catch (std::exception& e) {
70299       {
70300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70301       };
70302     } catch (Dali::DaliException e) {
70303       {
70304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70305       };
70306     } catch (...) {
70307       {
70308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70309       };
70310     }
70311   }
70312
70313 }
70314
70315
70316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
70317   void * jresult ;
70318   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
70319   Dali::Vector4 result;
70320
70321   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70322   {
70323     try {
70324       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
70325     } catch (std::out_of_range& e) {
70326       {
70327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70328       };
70329     } catch (std::exception& e) {
70330       {
70331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70332       };
70333     } catch (Dali::DaliException e) {
70334       {
70335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70336       };
70337     } catch (...) {
70338       {
70339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70340       };
70341     }
70342   }
70343
70344   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
70345   return jresult;
70346 }
70347
70348
70349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
70350   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
70351   float arg2 ;
70352
70353   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70354   arg2 = (float)jarg2;
70355   {
70356     try {
70357       (arg1)->SetOvershootAnimationSpeed(arg2);
70358     } catch (std::out_of_range& e) {
70359       {
70360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70361       };
70362     } catch (std::exception& e) {
70363       {
70364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70365       };
70366     } catch (Dali::DaliException e) {
70367       {
70368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70369       };
70370     } catch (...) {
70371       {
70372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70373       };
70374     }
70375   }
70376
70377 }
70378
70379
70380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
70381   float jresult ;
70382   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
70383   float result;
70384
70385   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70386   {
70387     try {
70388       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
70389     } catch (std::out_of_range& e) {
70390       {
70391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70392       };
70393     } catch (std::exception& e) {
70394       {
70395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70396       };
70397     } catch (Dali::DaliException e) {
70398       {
70399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70400       };
70401     } catch (...) {
70402       {
70403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70404       };
70405     }
70406   }
70407
70408   jresult = result;
70409   return jresult;
70410 }
70411
70412
70413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
70414   void * jresult ;
70415   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
70416   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
70417
70418   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70419   {
70420     try {
70421       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
70422     } catch (std::out_of_range& e) {
70423       {
70424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70425       };
70426     } catch (std::exception& e) {
70427       {
70428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70429       };
70430     } catch (Dali::DaliException e) {
70431       {
70432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70433       };
70434     } catch (...) {
70435       {
70436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70437       };
70438     }
70439   }
70440
70441   jresult = (void *)result;
70442   return jresult;
70443 }
70444
70445
70446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
70447   void * jresult ;
70448   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
70449   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
70450
70451   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70452   {
70453     try {
70454       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
70455     } catch (std::out_of_range& e) {
70456       {
70457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70458       };
70459     } catch (std::exception& e) {
70460       {
70461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70462       };
70463     } catch (Dali::DaliException e) {
70464       {
70465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70466       };
70467     } catch (...) {
70468       {
70469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70470       };
70471     }
70472   }
70473
70474   jresult = (void *)result;
70475   return jresult;
70476 }
70477
70478
70479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
70480   void * jresult ;
70481   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
70482   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
70483
70484   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70485   {
70486     try {
70487       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
70488     } catch (std::out_of_range& e) {
70489       {
70490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70491       };
70492     } catch (std::exception& e) {
70493       {
70494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70495       };
70496     } catch (Dali::DaliException e) {
70497       {
70498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70499       };
70500     } catch (...) {
70501       {
70502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70503       };
70504     }
70505   }
70506
70507   jresult = (void *)result;
70508   return jresult;
70509 }
70510
70511
70512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
70513   unsigned int jresult ;
70514   Dali::Toolkit::ControlOrientation::Type arg1 ;
70515   bool result;
70516
70517   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
70518   {
70519     try {
70520       result = (bool)Dali::Toolkit::IsVertical(arg1);
70521     } catch (std::out_of_range& e) {
70522       {
70523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70524       };
70525     } catch (std::exception& e) {
70526       {
70527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70528       };
70529     } catch (Dali::DaliException e) {
70530       {
70531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70532       };
70533     } catch (...) {
70534       {
70535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70536       };
70537     }
70538   }
70539
70540   jresult = result;
70541   return jresult;
70542 }
70543
70544
70545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
70546   unsigned int jresult ;
70547   Dali::Toolkit::ControlOrientation::Type arg1 ;
70548   bool result;
70549
70550   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
70551   {
70552     try {
70553       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
70554     } catch (std::out_of_range& e) {
70555       {
70556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70557       };
70558     } catch (std::exception& e) {
70559       {
70560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70561       };
70562     } catch (Dali::DaliException e) {
70563       {
70564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70565       };
70566     } catch (...) {
70567       {
70568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70569       };
70570     }
70571   }
70572
70573   jresult = result;
70574   return jresult;
70575 }
70576
70577
70578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
70579   void * jresult ;
70580   unsigned int arg1 ;
70581   unsigned int arg2 ;
70582   Dali::Toolkit::ItemRange *result = 0 ;
70583
70584   arg1 = (unsigned int)jarg1;
70585   arg2 = (unsigned int)jarg2;
70586   {
70587     try {
70588       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
70589     } catch (std::out_of_range& e) {
70590       {
70591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70592       };
70593     } catch (std::exception& e) {
70594       {
70595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70596       };
70597     } catch (Dali::DaliException e) {
70598       {
70599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70600       };
70601     } catch (...) {
70602       {
70603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70604       };
70605     }
70606   }
70607
70608   jresult = (void *)result;
70609   return jresult;
70610 }
70611
70612
70613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
70614   void * jresult ;
70615   Dali::Toolkit::ItemRange *arg1 = 0 ;
70616   Dali::Toolkit::ItemRange *result = 0 ;
70617
70618   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
70619   if (!arg1) {
70620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
70621     return 0;
70622   }
70623   {
70624     try {
70625       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
70626     } catch (std::out_of_range& e) {
70627       {
70628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70629       };
70630     } catch (std::exception& e) {
70631       {
70632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70633       };
70634     } catch (Dali::DaliException e) {
70635       {
70636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70637       };
70638     } catch (...) {
70639       {
70640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70641       };
70642     }
70643   }
70644
70645   jresult = (void *)result;
70646   return jresult;
70647 }
70648
70649
70650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
70651   void * jresult ;
70652   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
70653   Dali::Toolkit::ItemRange *arg2 = 0 ;
70654   Dali::Toolkit::ItemRange *result = 0 ;
70655
70656   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
70657   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
70658   if (!arg2) {
70659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
70660     return 0;
70661   }
70662   {
70663     try {
70664       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
70665     } catch (std::out_of_range& e) {
70666       {
70667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70668       };
70669     } catch (std::exception& e) {
70670       {
70671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70672       };
70673     } catch (Dali::DaliException e) {
70674       {
70675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70676       };
70677     } catch (...) {
70678       {
70679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70680       };
70681     }
70682   }
70683
70684   jresult = (void *)result;
70685   return jresult;
70686 }
70687
70688
70689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
70690   unsigned int jresult ;
70691   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
70692   unsigned int arg2 ;
70693   bool result;
70694
70695   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
70696   arg2 = (unsigned int)jarg2;
70697   {
70698     try {
70699       result = (bool)(arg1)->Within(arg2);
70700     } catch (std::out_of_range& e) {
70701       {
70702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70703       };
70704     } catch (std::exception& e) {
70705       {
70706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70707       };
70708     } catch (Dali::DaliException e) {
70709       {
70710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70711       };
70712     } catch (...) {
70713       {
70714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70715       };
70716     }
70717   }
70718
70719   jresult = result;
70720   return jresult;
70721 }
70722
70723
70724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
70725   void * jresult ;
70726   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
70727   Dali::Toolkit::ItemRange *arg2 = 0 ;
70728   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
70729
70730   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
70731   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
70732   if (!arg2) {
70733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
70734     return 0;
70735   }
70736   {
70737     try {
70738       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
70739     } catch (std::out_of_range& e) {
70740       {
70741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70742       };
70743     } catch (std::exception& e) {
70744       {
70745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70746       };
70747     } catch (Dali::DaliException e) {
70748       {
70749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70750       };
70751     } catch (...) {
70752       {
70753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70754       };
70755     }
70756   }
70757
70758   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
70759   return jresult;
70760 }
70761
70762
70763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
70764   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
70765   unsigned int arg2 ;
70766
70767   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
70768   arg2 = (unsigned int)jarg2;
70769   if (arg1) (arg1)->begin = arg2;
70770 }
70771
70772
70773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
70774   unsigned int jresult ;
70775   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
70776   unsigned int result;
70777
70778   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
70779   result = (unsigned int) ((arg1)->begin);
70780   jresult = result;
70781   return jresult;
70782 }
70783
70784
70785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
70786   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
70787   unsigned int arg2 ;
70788
70789   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
70790   arg2 = (unsigned int)jarg2;
70791   if (arg1) (arg1)->end = arg2;
70792 }
70793
70794
70795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
70796   unsigned int jresult ;
70797   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
70798   unsigned int result;
70799
70800   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
70801   result = (unsigned int) ((arg1)->end);
70802   jresult = result;
70803   return jresult;
70804 }
70805
70806
70807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
70808   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
70809
70810   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
70811   {
70812     try {
70813       delete arg1;
70814     } catch (std::out_of_range& e) {
70815       {
70816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70817       };
70818     } catch (std::exception& e) {
70819       {
70820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70821       };
70822     } catch (Dali::DaliException e) {
70823       {
70824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70825       };
70826     } catch (...) {
70827       {
70828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70829       };
70830     }
70831   }
70832
70833 }
70834
70835
70836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
70837   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70838
70839   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70840   {
70841     try {
70842       delete arg1;
70843     } catch (std::out_of_range& e) {
70844       {
70845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70846       };
70847     } catch (std::exception& e) {
70848       {
70849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70850       };
70851     } catch (Dali::DaliException e) {
70852       {
70853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70854       };
70855     } catch (...) {
70856       {
70857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70858       };
70859     }
70860   }
70861
70862 }
70863
70864
70865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
70866   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70867   Dali::Toolkit::ControlOrientation::Type arg2 ;
70868
70869   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70870   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
70871   {
70872     try {
70873       (arg1)->SetOrientation(arg2);
70874     } catch (std::out_of_range& e) {
70875       {
70876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70877       };
70878     } catch (std::exception& e) {
70879       {
70880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70881       };
70882     } catch (Dali::DaliException e) {
70883       {
70884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70885       };
70886     } catch (...) {
70887       {
70888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70889       };
70890     }
70891   }
70892
70893 }
70894
70895
70896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
70897   int jresult ;
70898   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70899   Dali::Toolkit::ControlOrientation::Type result;
70900
70901   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70902   {
70903     try {
70904       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
70905     } catch (std::out_of_range& e) {
70906       {
70907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70908       };
70909     } catch (std::exception& e) {
70910       {
70911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70912       };
70913     } catch (Dali::DaliException e) {
70914       {
70915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70916       };
70917     } catch (...) {
70918       {
70919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70920       };
70921     }
70922   }
70923
70924   jresult = (int)result;
70925   return jresult;
70926 }
70927
70928
70929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
70930   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70931   Dali::Property::Map *arg2 = 0 ;
70932
70933   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70934   arg2 = (Dali::Property::Map *)jarg2;
70935   if (!arg2) {
70936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
70937     return ;
70938   }
70939   {
70940     try {
70941       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
70942     } catch (std::out_of_range& e) {
70943       {
70944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70945       };
70946     } catch (std::exception& e) {
70947       {
70948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70949       };
70950     } catch (Dali::DaliException e) {
70951       {
70952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70953       };
70954     } catch (...) {
70955       {
70956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70957       };
70958     }
70959   }
70960
70961 }
70962
70963
70964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
70965   void * jresult ;
70966   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70967   Dali::Property::Map result;
70968
70969   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70970   {
70971     try {
70972       result = (arg1)->GetLayoutProperties();
70973     } catch (std::out_of_range& e) {
70974       {
70975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70976       };
70977     } catch (std::exception& e) {
70978       {
70979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70980       };
70981     } catch (Dali::DaliException e) {
70982       {
70983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70984       };
70985     } catch (...) {
70986       {
70987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70988       };
70989     }
70990   }
70991
70992   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
70993   return jresult;
70994 }
70995
70996
70997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
70998   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70999   unsigned int arg2 ;
71000   Dali::Vector3 *arg3 = 0 ;
71001   Dali::Vector3 *arg4 = 0 ;
71002
71003   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71004   arg2 = (unsigned int)jarg2;
71005   arg3 = (Dali::Vector3 *)jarg3;
71006   if (!arg3) {
71007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71008     return ;
71009   }
71010   arg4 = (Dali::Vector3 *)jarg4;
71011   if (!arg4) {
71012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71013     return ;
71014   }
71015   {
71016     try {
71017       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
71018     } catch (std::out_of_range& e) {
71019       {
71020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71021       };
71022     } catch (std::exception& e) {
71023       {
71024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71025       };
71026     } catch (Dali::DaliException e) {
71027       {
71028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71029       };
71030     } catch (...) {
71031       {
71032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71033       };
71034     }
71035   }
71036
71037 }
71038
71039
71040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
71041   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71042   Dali::Vector3 *arg2 = 0 ;
71043
71044   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71045   arg2 = (Dali::Vector3 *)jarg2;
71046   if (!arg2) {
71047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71048     return ;
71049   }
71050   {
71051     try {
71052       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
71053     } catch (std::out_of_range& e) {
71054       {
71055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71056       };
71057     } catch (std::exception& e) {
71058       {
71059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71060       };
71061     } catch (Dali::DaliException e) {
71062       {
71063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71064       };
71065     } catch (...) {
71066       {
71067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71068       };
71069     }
71070   }
71071
71072 }
71073
71074
71075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
71076   float jresult ;
71077   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71078   unsigned int arg2 ;
71079   Dali::Vector3 arg3 ;
71080   Dali::Vector3 *argp3 ;
71081   float result;
71082
71083   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71084   arg2 = (unsigned int)jarg2;
71085   argp3 = (Dali::Vector3 *)jarg3;
71086   if (!argp3) {
71087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71088     return 0;
71089   }
71090   arg3 = *argp3;
71091   {
71092     try {
71093       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
71094     } catch (std::out_of_range& e) {
71095       {
71096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71097       };
71098     } catch (std::exception& e) {
71099       {
71100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71101       };
71102     } catch (Dali::DaliException e) {
71103       {
71104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71105       };
71106     } catch (...) {
71107       {
71108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71109       };
71110     }
71111   }
71112
71113   jresult = result;
71114   return jresult;
71115 }
71116
71117
71118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
71119   float jresult ;
71120   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71121   float arg2 ;
71122   float result;
71123
71124   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71125   arg2 = (float)jarg2;
71126   {
71127     try {
71128       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
71129     } catch (std::out_of_range& e) {
71130       {
71131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71132       };
71133     } catch (std::exception& e) {
71134       {
71135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71136       };
71137     } catch (Dali::DaliException e) {
71138       {
71139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71140       };
71141     } catch (...) {
71142       {
71143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71144       };
71145     }
71146   }
71147
71148   jresult = result;
71149   return jresult;
71150 }
71151
71152
71153 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
71154   float jresult ;
71155   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71156   unsigned int arg2 ;
71157   float result;
71158
71159   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71160   arg2 = (unsigned int)jarg2;
71161   {
71162     try {
71163       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
71164     } catch (std::out_of_range& e) {
71165       {
71166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71167       };
71168     } catch (std::exception& e) {
71169       {
71170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71171       };
71172     } catch (Dali::DaliException e) {
71173       {
71174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71175       };
71176     } catch (...) {
71177       {
71178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71179       };
71180     }
71181   }
71182
71183   jresult = result;
71184   return jresult;
71185 }
71186
71187
71188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
71189   void * jresult ;
71190   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71191   float arg2 ;
71192   Dali::Vector3 arg3 ;
71193   Dali::Vector3 *argp3 ;
71194   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
71195
71196   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71197   arg2 = (float)jarg2;
71198   argp3 = (Dali::Vector3 *)jarg3;
71199   if (!argp3) {
71200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71201     return 0;
71202   }
71203   arg3 = *argp3;
71204   {
71205     try {
71206       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
71207     } catch (std::out_of_range& e) {
71208       {
71209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71210       };
71211     } catch (std::exception& e) {
71212       {
71213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71214       };
71215     } catch (Dali::DaliException e) {
71216       {
71217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71218       };
71219     } catch (...) {
71220       {
71221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71222       };
71223     }
71224   }
71225
71226   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
71227   return jresult;
71228 }
71229
71230
71231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
71232   float jresult ;
71233   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71234   int arg2 ;
71235   float arg3 ;
71236   Dali::Vector3 *arg4 = 0 ;
71237   float result;
71238
71239   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71240   arg2 = (int)jarg2;
71241   arg3 = (float)jarg3;
71242   arg4 = (Dali::Vector3 *)jarg4;
71243   if (!arg4) {
71244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71245     return 0;
71246   }
71247   {
71248     try {
71249       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
71250     } catch (std::out_of_range& e) {
71251       {
71252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71253       };
71254     } catch (std::exception& e) {
71255       {
71256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71257       };
71258     } catch (Dali::DaliException e) {
71259       {
71260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71261       };
71262     } catch (...) {
71263       {
71264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71265       };
71266     }
71267   }
71268
71269   jresult = result;
71270   return jresult;
71271 }
71272
71273
71274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
71275   unsigned int jresult ;
71276   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71277   Dali::Vector3 arg2 ;
71278   Dali::Vector3 *argp2 ;
71279   unsigned int result;
71280
71281   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71282   argp2 = (Dali::Vector3 *)jarg2;
71283   if (!argp2) {
71284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71285     return 0;
71286   }
71287   arg2 = *argp2;
71288   {
71289     try {
71290       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
71291     } catch (std::out_of_range& e) {
71292       {
71293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71294       };
71295     } catch (std::exception& e) {
71296       {
71297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71298       };
71299     } catch (Dali::DaliException e) {
71300       {
71301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71302       };
71303     } catch (...) {
71304       {
71305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71306       };
71307     }
71308   }
71309
71310   jresult = result;
71311   return jresult;
71312 }
71313
71314
71315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
71316   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71317   unsigned int arg2 ;
71318   Dali::Vector3 *arg3 = 0 ;
71319   Dali::Vector3 *arg4 = 0 ;
71320
71321   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71322   arg2 = (unsigned int)jarg2;
71323   arg3 = (Dali::Vector3 *)jarg3;
71324   if (!arg3) {
71325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71326     return ;
71327   }
71328   arg4 = (Dali::Vector3 *)jarg4;
71329   if (!arg4) {
71330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71331     return ;
71332   }
71333   {
71334     try {
71335       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
71336     } catch (std::out_of_range& e) {
71337       {
71338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71339       };
71340     } catch (std::exception& e) {
71341       {
71342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71343       };
71344     } catch (Dali::DaliException e) {
71345       {
71346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71347       };
71348     } catch (...) {
71349       {
71350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71351       };
71352     }
71353   }
71354
71355 }
71356
71357
71358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
71359   void * jresult ;
71360   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71361   Dali::Degree result;
71362
71363   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71364   {
71365     try {
71366       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
71367     } catch (std::out_of_range& e) {
71368       {
71369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71370       };
71371     } catch (std::exception& e) {
71372       {
71373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71374       };
71375     } catch (Dali::DaliException e) {
71376       {
71377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71378       };
71379     } catch (...) {
71380       {
71381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71382       };
71383     }
71384   }
71385
71386   jresult = new Dali::Degree((const Dali::Degree &)result);
71387   return jresult;
71388 }
71389
71390
71391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
71392   float jresult ;
71393   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71394   float result;
71395
71396   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71397   {
71398     try {
71399       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
71400     } catch (std::out_of_range& e) {
71401       {
71402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71403       };
71404     } catch (std::exception& e) {
71405       {
71406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71407       };
71408     } catch (Dali::DaliException e) {
71409       {
71410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71411       };
71412     } catch (...) {
71413       {
71414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71415       };
71416     }
71417   }
71418
71419   jresult = result;
71420   return jresult;
71421 }
71422
71423
71424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
71425   float jresult ;
71426   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71427   float result;
71428
71429   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71430   {
71431     try {
71432       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
71433     } catch (std::out_of_range& e) {
71434       {
71435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71436       };
71437     } catch (std::exception& e) {
71438       {
71439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71440       };
71441     } catch (Dali::DaliException e) {
71442       {
71443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71444       };
71445     } catch (...) {
71446       {
71447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71448       };
71449     }
71450   }
71451
71452   jresult = result;
71453   return jresult;
71454 }
71455
71456
71457 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
71458   float jresult ;
71459   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71460   float result;
71461
71462   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71463   {
71464     try {
71465       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
71466     } catch (std::out_of_range& e) {
71467       {
71468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71469       };
71470     } catch (std::exception& e) {
71471       {
71472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71473       };
71474     } catch (Dali::DaliException e) {
71475       {
71476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71477       };
71478     } catch (...) {
71479       {
71480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71481       };
71482     }
71483   }
71484
71485   jresult = result;
71486   return jresult;
71487 }
71488
71489
71490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
71491   int jresult ;
71492   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71493   int arg2 ;
71494   int arg3 ;
71495   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
71496   bool arg5 ;
71497   int result;
71498
71499   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71500   arg2 = (int)jarg2;
71501   arg3 = (int)jarg3;
71502   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
71503   arg5 = jarg5 ? true : false;
71504   {
71505     try {
71506       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
71507     } catch (std::out_of_range& e) {
71508       {
71509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71510       };
71511     } catch (std::exception& e) {
71512       {
71513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71514       };
71515     } catch (Dali::DaliException e) {
71516       {
71517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71518       };
71519     } catch (...) {
71520       {
71521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71522       };
71523     }
71524   }
71525
71526   jresult = result;
71527   return jresult;
71528 }
71529
71530
71531 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
71532   float jresult ;
71533   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71534   float result;
71535
71536   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71537   {
71538     try {
71539       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
71540     } catch (std::out_of_range& e) {
71541       {
71542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71543       };
71544     } catch (std::exception& e) {
71545       {
71546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71547       };
71548     } catch (Dali::DaliException e) {
71549       {
71550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71551       };
71552     } catch (...) {
71553       {
71554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71555       };
71556     }
71557   }
71558
71559   jresult = result;
71560   return jresult;
71561 }
71562
71563
71564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
71565   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71566   Dali::Actor *arg2 = 0 ;
71567   int arg3 ;
71568   Dali::Vector3 *arg4 = 0 ;
71569   Dali::Actor *arg5 = 0 ;
71570
71571   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71572   arg2 = (Dali::Actor *)jarg2;
71573   if (!arg2) {
71574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
71575     return ;
71576   }
71577   arg3 = (int)jarg3;
71578   arg4 = (Dali::Vector3 *)jarg4;
71579   if (!arg4) {
71580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71581     return ;
71582   }
71583   arg5 = (Dali::Actor *)jarg5;
71584   if (!arg5) {
71585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
71586     return ;
71587   }
71588   {
71589     try {
71590       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
71591     } catch (std::out_of_range& e) {
71592       {
71593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71594       };
71595     } catch (std::exception& e) {
71596       {
71597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71598       };
71599     } catch (Dali::DaliException e) {
71600       {
71601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71602       };
71603     } catch (...) {
71604       {
71605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71606       };
71607     }
71608   }
71609
71610 }
71611
71612
71613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
71614   void * jresult ;
71615   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71616   int arg2 ;
71617   float arg3 ;
71618   Dali::Vector3 *arg4 = 0 ;
71619   Dali::Vector3 result;
71620
71621   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71622   arg2 = (int)jarg2;
71623   arg3 = (float)jarg3;
71624   arg4 = (Dali::Vector3 *)jarg4;
71625   if (!arg4) {
71626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71627     return 0;
71628   }
71629   {
71630     try {
71631       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
71632     } catch (std::out_of_range& e) {
71633       {
71634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71635       };
71636     } catch (std::exception& e) {
71637       {
71638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71639       };
71640     } catch (Dali::DaliException e) {
71641       {
71642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71643       };
71644     } catch (...) {
71645       {
71646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71647       };
71648     }
71649   }
71650
71651   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71652   return jresult;
71653 }
71654
71655
71656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
71657   void * jresult ;
71658   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
71659   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71660
71661   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
71662   {
71663     try {
71664       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
71665     } catch (std::out_of_range& e) {
71666       {
71667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71668       };
71669     } catch (std::exception& e) {
71670       {
71671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71672       };
71673     } catch (Dali::DaliException e) {
71674       {
71675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71676       };
71677     } catch (...) {
71678       {
71679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71680       };
71681     }
71682   }
71683
71684   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71685   return jresult;
71686 }
71687
71688
71689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
71690   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
71691
71692   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
71693   {
71694     try {
71695       delete arg1;
71696     } catch (std::out_of_range& e) {
71697       {
71698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71699       };
71700     } catch (std::exception& e) {
71701       {
71702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71703       };
71704     } catch (Dali::DaliException e) {
71705       {
71706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71707       };
71708     } catch (...) {
71709       {
71710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71711       };
71712     }
71713   }
71714
71715 }
71716
71717
71718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
71719   unsigned int jresult ;
71720   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
71721   unsigned int result;
71722
71723   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
71724   {
71725     try {
71726       result = (unsigned int)(arg1)->GetNumberOfItems();
71727     } catch (std::out_of_range& e) {
71728       {
71729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71730       };
71731     } catch (std::exception& e) {
71732       {
71733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71734       };
71735     } catch (Dali::DaliException e) {
71736       {
71737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71738       };
71739     } catch (...) {
71740       {
71741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71742       };
71743     }
71744   }
71745
71746   jresult = result;
71747   return jresult;
71748 }
71749
71750
71751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
71752   void * jresult ;
71753   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
71754   unsigned int arg2 ;
71755   Dali::Actor result;
71756
71757   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
71758   arg2 = (unsigned int)jarg2;
71759   {
71760     try {
71761       result = (arg1)->NewItem(arg2);
71762     } catch (std::out_of_range& e) {
71763       {
71764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71765       };
71766     } catch (std::exception& e) {
71767       {
71768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71769       };
71770     } catch (Dali::DaliException e) {
71771       {
71772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71773       };
71774     } catch (...) {
71775       {
71776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71777       };
71778     }
71779   }
71780
71781   jresult = new Dali::Actor((const Dali::Actor &)result);
71782   return jresult;
71783 }
71784
71785
71786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
71787   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
71788   unsigned int arg2 ;
71789   Dali::Actor arg3 ;
71790   Dali::Actor *argp3 ;
71791
71792   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
71793   arg2 = (unsigned int)jarg2;
71794   argp3 = (Dali::Actor *)jarg3;
71795   if (!argp3) {
71796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71797     return ;
71798   }
71799   arg3 = *argp3;
71800   {
71801     try {
71802       (arg1)->ItemReleased(arg2,arg3);
71803     } catch (std::out_of_range& e) {
71804       {
71805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71806       };
71807     } catch (std::exception& e) {
71808       {
71809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71810       };
71811     } catch (Dali::DaliException e) {
71812       {
71813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71814       };
71815     } catch (...) {
71816       {
71817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71818       };
71819     }
71820   }
71821
71822 }
71823
71824
71825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
71826   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
71827   unsigned int arg2 ;
71828   Dali::Actor arg3 ;
71829   Dali::Actor *argp3 ;
71830
71831   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
71832   arg2 = (unsigned int)jarg2;
71833   argp3 = (Dali::Actor *)jarg3;
71834   if (!argp3) {
71835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71836     return ;
71837   }
71838   arg3 = *argp3;
71839   {
71840     try {
71841       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
71842     } catch (std::out_of_range& e) {
71843       {
71844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71845       };
71846     } catch (std::exception& e) {
71847       {
71848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71849       };
71850     } catch (Dali::DaliException e) {
71851       {
71852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71853       };
71854     } catch (...) {
71855       {
71856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71857       };
71858     }
71859   }
71860
71861 }
71862
71863
71864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
71865   void * jresult ;
71866   Dali::Toolkit::ItemFactory *result = 0 ;
71867
71868   {
71869     try {
71870       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
71871     } catch (std::out_of_range& e) {
71872       {
71873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71874       };
71875     } catch (std::exception& e) {
71876       {
71877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71878       };
71879     } catch (Dali::DaliException e) {
71880       {
71881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71882       };
71883     } catch (...) {
71884       {
71885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71886       };
71887     }
71888   }
71889
71890   jresult = (void *)result;
71891   return jresult;
71892 }
71893
71894
71895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_director_connect(void *objarg, SwigDirector_ItemFactory::SWIG_Callback0_t callback0, SwigDirector_ItemFactory::SWIG_Callback1_t callback1, SwigDirector_ItemFactory::SWIG_Callback2_t callback2) {
71896   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
71897   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
71898   if (director) {
71899     director->swig_connect_director(callback0, callback1, callback2);
71900   }
71901 }
71902
71903
71904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
71905   int jresult ;
71906   int result;
71907
71908   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
71909   jresult = (int)result;
71910   return jresult;
71911 }
71912
71913
71914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
71915   int jresult ;
71916   int result;
71917
71918   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
71919   jresult = (int)result;
71920   return jresult;
71921 }
71922
71923
71924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
71925   int jresult ;
71926   int result;
71927
71928   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
71929   jresult = (int)result;
71930   return jresult;
71931 }
71932
71933
71934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
71935   int jresult ;
71936   int result;
71937
71938   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
71939   jresult = (int)result;
71940   return jresult;
71941 }
71942
71943
71944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
71945   int jresult ;
71946   int result;
71947
71948   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
71949   jresult = (int)result;
71950   return jresult;
71951 }
71952
71953
71954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
71955   int jresult ;
71956   int result;
71957
71958   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
71959   jresult = (int)result;
71960   return jresult;
71961 }
71962
71963
71964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
71965   int jresult ;
71966   int result;
71967
71968   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
71969   jresult = (int)result;
71970   return jresult;
71971 }
71972
71973
71974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
71975   int jresult ;
71976   int result;
71977
71978   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
71979   jresult = (int)result;
71980   return jresult;
71981 }
71982
71983
71984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
71985   int jresult ;
71986   int result;
71987
71988   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
71989   jresult = (int)result;
71990   return jresult;
71991 }
71992
71993
71994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
71995   int jresult ;
71996   int result;
71997
71998   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
71999   jresult = (int)result;
72000   return jresult;
72001 }
72002
72003
72004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
72005   int jresult ;
72006   int result;
72007
72008   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
72009   jresult = (int)result;
72010   return jresult;
72011 }
72012
72013
72014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
72015   void * jresult ;
72016   Dali::Toolkit::ItemView::Property *result = 0 ;
72017
72018   {
72019     try {
72020       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
72021     } catch (std::out_of_range& e) {
72022       {
72023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72024       };
72025     } catch (std::exception& e) {
72026       {
72027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72028       };
72029     } catch (Dali::DaliException e) {
72030       {
72031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72032       };
72033     } catch (...) {
72034       {
72035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72036       };
72037     }
72038   }
72039
72040   jresult = (void *)result;
72041   return jresult;
72042 }
72043
72044
72045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
72046   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
72047
72048   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
72049   {
72050     try {
72051       delete arg1;
72052     } catch (std::out_of_range& e) {
72053       {
72054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72055       };
72056     } catch (std::exception& e) {
72057       {
72058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72059       };
72060     } catch (Dali::DaliException e) {
72061       {
72062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72063       };
72064     } catch (...) {
72065       {
72066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72067       };
72068     }
72069   }
72070
72071 }
72072
72073
72074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
72075   void * jresult ;
72076   Dali::Toolkit::ItemView *result = 0 ;
72077
72078   {
72079     try {
72080       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
72081     } catch (std::out_of_range& e) {
72082       {
72083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72084       };
72085     } catch (std::exception& e) {
72086       {
72087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72088       };
72089     } catch (Dali::DaliException e) {
72090       {
72091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72092       };
72093     } catch (...) {
72094       {
72095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72096       };
72097     }
72098   }
72099
72100   jresult = (void *)result;
72101   return jresult;
72102 }
72103
72104
72105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
72106   void * jresult ;
72107   Dali::Toolkit::ItemView *arg1 = 0 ;
72108   Dali::Toolkit::ItemView *result = 0 ;
72109
72110   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72111   if (!arg1) {
72112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
72113     return 0;
72114   }
72115   {
72116     try {
72117       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
72118     } catch (std::out_of_range& e) {
72119       {
72120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72121       };
72122     } catch (std::exception& e) {
72123       {
72124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72125       };
72126     } catch (Dali::DaliException e) {
72127       {
72128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72129       };
72130     } catch (...) {
72131       {
72132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72133       };
72134     }
72135   }
72136
72137   jresult = (void *)result;
72138   return jresult;
72139 }
72140
72141
72142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
72143   void * jresult ;
72144   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72145   Dali::Toolkit::ItemView *arg2 = 0 ;
72146   Dali::Toolkit::ItemView *result = 0 ;
72147
72148   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72149   arg2 = (Dali::Toolkit::ItemView *)jarg2;
72150   if (!arg2) {
72151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
72152     return 0;
72153   }
72154   {
72155     try {
72156       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
72157     } catch (std::out_of_range& e) {
72158       {
72159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72160       };
72161     } catch (std::exception& e) {
72162       {
72163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72164       };
72165     } catch (Dali::DaliException e) {
72166       {
72167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72168       };
72169     } catch (...) {
72170       {
72171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72172       };
72173     }
72174   }
72175
72176   jresult = (void *)result;
72177   return jresult;
72178 }
72179
72180
72181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
72182   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72183
72184   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72185   {
72186     try {
72187       delete arg1;
72188     } catch (std::out_of_range& e) {
72189       {
72190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72191       };
72192     } catch (std::exception& e) {
72193       {
72194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72195       };
72196     } catch (Dali::DaliException e) {
72197       {
72198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72199       };
72200     } catch (...) {
72201       {
72202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72203       };
72204     }
72205   }
72206
72207 }
72208
72209
72210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
72211   void * jresult ;
72212   Dali::Toolkit::ItemFactory *arg1 = 0 ;
72213   Dali::Toolkit::ItemView result;
72214
72215   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
72216   if (!arg1) {
72217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
72218     return 0;
72219   }
72220   {
72221     try {
72222       result = Dali::Toolkit::ItemView::New(*arg1);
72223     } catch (std::out_of_range& e) {
72224       {
72225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72226       };
72227     } catch (std::exception& e) {
72228       {
72229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72230       };
72231     } catch (Dali::DaliException e) {
72232       {
72233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72234       };
72235     } catch (...) {
72236       {
72237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72238       };
72239     }
72240   }
72241
72242   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
72243   return jresult;
72244 }
72245
72246
72247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
72248   void * jresult ;
72249   Dali::BaseHandle arg1 ;
72250   Dali::BaseHandle *argp1 ;
72251   Dali::Toolkit::ItemView result;
72252
72253   argp1 = (Dali::BaseHandle *)jarg1;
72254   if (!argp1) {
72255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72256     return 0;
72257   }
72258   arg1 = *argp1;
72259   {
72260     try {
72261       result = Dali::Toolkit::ItemView::DownCast(arg1);
72262     } catch (std::out_of_range& e) {
72263       {
72264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72265       };
72266     } catch (std::exception& e) {
72267       {
72268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72269       };
72270     } catch (Dali::DaliException e) {
72271       {
72272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72273       };
72274     } catch (...) {
72275       {
72276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72277       };
72278     }
72279   }
72280
72281   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
72282   return jresult;
72283 }
72284
72285
72286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
72287   unsigned int jresult ;
72288   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72289   unsigned int result;
72290
72291   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72292   {
72293     try {
72294       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
72295     } catch (std::out_of_range& e) {
72296       {
72297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72298       };
72299     } catch (std::exception& e) {
72300       {
72301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72302       };
72303     } catch (Dali::DaliException e) {
72304       {
72305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72306       };
72307     } catch (...) {
72308       {
72309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72310       };
72311     }
72312   }
72313
72314   jresult = result;
72315   return jresult;
72316 }
72317
72318
72319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
72320   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72321   Dali::Toolkit::ItemLayout *arg2 = 0 ;
72322
72323   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72324   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
72325   if (!arg2) {
72326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
72327     return ;
72328   }
72329   {
72330     try {
72331       (arg1)->AddLayout(*arg2);
72332     } catch (std::out_of_range& e) {
72333       {
72334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72335       };
72336     } catch (std::exception& e) {
72337       {
72338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72339       };
72340     } catch (Dali::DaliException e) {
72341       {
72342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72343       };
72344     } catch (...) {
72345       {
72346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72347       };
72348     }
72349   }
72350
72351 }
72352
72353
72354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
72355   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72356   unsigned int arg2 ;
72357
72358   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72359   arg2 = (unsigned int)jarg2;
72360   {
72361     try {
72362       (arg1)->RemoveLayout(arg2);
72363     } catch (std::out_of_range& e) {
72364       {
72365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72366       };
72367     } catch (std::exception& e) {
72368       {
72369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72370       };
72371     } catch (Dali::DaliException e) {
72372       {
72373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72374       };
72375     } catch (...) {
72376       {
72377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72378       };
72379     }
72380   }
72381
72382 }
72383
72384
72385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
72386   void * jresult ;
72387   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72388   unsigned int arg2 ;
72389   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
72390
72391   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72392   arg2 = (unsigned int)jarg2;
72393   {
72394     try {
72395       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
72396     } catch (std::out_of_range& e) {
72397       {
72398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72399       };
72400     } catch (std::exception& e) {
72401       {
72402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72403       };
72404     } catch (Dali::DaliException e) {
72405       {
72406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72407       };
72408     } catch (...) {
72409       {
72410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72411       };
72412     }
72413   }
72414
72415   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
72416   return jresult;
72417 }
72418
72419
72420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
72421   void * jresult ;
72422   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72423   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
72424
72425   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72426   {
72427     try {
72428       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
72429     } catch (std::out_of_range& e) {
72430       {
72431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72432       };
72433     } catch (std::exception& e) {
72434       {
72435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72436       };
72437     } catch (Dali::DaliException e) {
72438       {
72439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72440       };
72441     } catch (...) {
72442       {
72443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72444       };
72445     }
72446   }
72447
72448   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
72449   return jresult;
72450 }
72451
72452
72453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
72454   float jresult ;
72455   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72456   Dali::Toolkit::ItemId arg2 ;
72457   float result;
72458
72459   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72460   arg2 = (Dali::Toolkit::ItemId)jarg2;
72461   {
72462     try {
72463       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
72464     } catch (std::out_of_range& e) {
72465       {
72466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72467       };
72468     } catch (std::exception& e) {
72469       {
72470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72471       };
72472     } catch (Dali::DaliException e) {
72473       {
72474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72475       };
72476     } catch (...) {
72477       {
72478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72479       };
72480     }
72481   }
72482
72483   jresult = result;
72484   return jresult;
72485 }
72486
72487
72488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
72489   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72490   unsigned int arg2 ;
72491   Dali::Vector3 arg3 ;
72492   float arg4 ;
72493   Dali::Vector3 *argp3 ;
72494
72495   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72496   arg2 = (unsigned int)jarg2;
72497   argp3 = (Dali::Vector3 *)jarg3;
72498   if (!argp3) {
72499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
72500     return ;
72501   }
72502   arg3 = *argp3;
72503   arg4 = (float)jarg4;
72504   {
72505     try {
72506       (arg1)->ActivateLayout(arg2,arg3,arg4);
72507     } catch (std::out_of_range& e) {
72508       {
72509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72510       };
72511     } catch (std::exception& e) {
72512       {
72513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72514       };
72515     } catch (Dali::DaliException e) {
72516       {
72517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72518       };
72519     } catch (...) {
72520       {
72521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72522       };
72523     }
72524   }
72525
72526 }
72527
72528
72529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
72530   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72531
72532   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72533   {
72534     try {
72535       (arg1)->DeactivateCurrentLayout();
72536     } catch (std::out_of_range& e) {
72537       {
72538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72539       };
72540     } catch (std::exception& e) {
72541       {
72542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72543       };
72544     } catch (Dali::DaliException e) {
72545       {
72546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72547       };
72548     } catch (...) {
72549       {
72550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72551       };
72552     }
72553   }
72554
72555 }
72556
72557
72558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
72559   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72560   float arg2 ;
72561
72562   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72563   arg2 = (float)jarg2;
72564   {
72565     try {
72566       (arg1)->SetMinimumSwipeSpeed(arg2);
72567     } catch (std::out_of_range& e) {
72568       {
72569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72570       };
72571     } catch (std::exception& e) {
72572       {
72573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72574       };
72575     } catch (Dali::DaliException e) {
72576       {
72577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72578       };
72579     } catch (...) {
72580       {
72581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72582       };
72583     }
72584   }
72585
72586 }
72587
72588
72589 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
72590   float jresult ;
72591   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72592   float result;
72593
72594   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72595   {
72596     try {
72597       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
72598     } catch (std::out_of_range& e) {
72599       {
72600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72601       };
72602     } catch (std::exception& e) {
72603       {
72604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72605       };
72606     } catch (Dali::DaliException e) {
72607       {
72608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72609       };
72610     } catch (...) {
72611       {
72612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72613       };
72614     }
72615   }
72616
72617   jresult = result;
72618   return jresult;
72619 }
72620
72621
72622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
72623   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72624   float arg2 ;
72625
72626   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72627   arg2 = (float)jarg2;
72628   {
72629     try {
72630       (arg1)->SetMinimumSwipeDistance(arg2);
72631     } catch (std::out_of_range& e) {
72632       {
72633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72634       };
72635     } catch (std::exception& e) {
72636       {
72637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72638       };
72639     } catch (Dali::DaliException e) {
72640       {
72641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72642       };
72643     } catch (...) {
72644       {
72645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72646       };
72647     }
72648   }
72649
72650 }
72651
72652
72653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
72654   float jresult ;
72655   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72656   float result;
72657
72658   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72659   {
72660     try {
72661       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
72662     } catch (std::out_of_range& e) {
72663       {
72664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72665       };
72666     } catch (std::exception& e) {
72667       {
72668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72669       };
72670     } catch (Dali::DaliException e) {
72671       {
72672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72673       };
72674     } catch (...) {
72675       {
72676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72677       };
72678     }
72679   }
72680
72681   jresult = result;
72682   return jresult;
72683 }
72684
72685
72686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
72687   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72688   float arg2 ;
72689
72690   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72691   arg2 = (float)jarg2;
72692   {
72693     try {
72694       (arg1)->SetWheelScrollDistanceStep(arg2);
72695     } catch (std::out_of_range& e) {
72696       {
72697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72698       };
72699     } catch (std::exception& e) {
72700       {
72701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72702       };
72703     } catch (Dali::DaliException e) {
72704       {
72705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72706       };
72707     } catch (...) {
72708       {
72709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72710       };
72711     }
72712   }
72713
72714 }
72715
72716
72717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
72718   float jresult ;
72719   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72720   float result;
72721
72722   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72723   {
72724     try {
72725       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
72726     } catch (std::out_of_range& e) {
72727       {
72728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72729       };
72730     } catch (std::exception& e) {
72731       {
72732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72733       };
72734     } catch (Dali::DaliException e) {
72735       {
72736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72737       };
72738     } catch (...) {
72739       {
72740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72741       };
72742     }
72743   }
72744
72745   jresult = result;
72746   return jresult;
72747 }
72748
72749
72750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
72751   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72752   bool arg2 ;
72753
72754   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72755   arg2 = jarg2 ? true : false;
72756   {
72757     try {
72758       (arg1)->SetAnchoring(arg2);
72759     } catch (std::out_of_range& e) {
72760       {
72761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72762       };
72763     } catch (std::exception& e) {
72764       {
72765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72766       };
72767     } catch (Dali::DaliException e) {
72768       {
72769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72770       };
72771     } catch (...) {
72772       {
72773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72774       };
72775     }
72776   }
72777
72778 }
72779
72780 //// ========================= end of part 3 =============================
72781
72782 //// ========================== start part 4 ===============================
72783
72784
72785 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
72786   unsigned int jresult ;
72787   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72788   bool result;
72789
72790   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72791   {
72792     try {
72793       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
72794     } catch (std::out_of_range& e) {
72795       {
72796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72797       };
72798     } catch (std::exception& e) {
72799       {
72800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72801       };
72802     } catch (Dali::DaliException e) {
72803       {
72804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72805       };
72806     } catch (...) {
72807       {
72808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72809       };
72810     }
72811   }
72812
72813   jresult = result;
72814   return jresult;
72815 }
72816
72817
72818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
72819   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72820   float arg2 ;
72821
72822   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72823   arg2 = (float)jarg2;
72824   {
72825     try {
72826       (arg1)->SetAnchoringDuration(arg2);
72827     } catch (std::out_of_range& e) {
72828       {
72829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72830       };
72831     } catch (std::exception& e) {
72832       {
72833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72834       };
72835     } catch (Dali::DaliException e) {
72836       {
72837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72838       };
72839     } catch (...) {
72840       {
72841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72842       };
72843     }
72844   }
72845
72846 }
72847
72848
72849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
72850   float jresult ;
72851   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72852   float result;
72853
72854   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72855   {
72856     try {
72857       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
72858     } catch (std::out_of_range& e) {
72859       {
72860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72861       };
72862     } catch (std::exception& e) {
72863       {
72864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72865       };
72866     } catch (Dali::DaliException e) {
72867       {
72868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72869       };
72870     } catch (...) {
72871       {
72872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72873       };
72874     }
72875   }
72876
72877   jresult = result;
72878   return jresult;
72879 }
72880
72881
72882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
72883   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72884   Dali::Toolkit::ItemId arg2 ;
72885   float arg3 ;
72886
72887   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72888   arg2 = (Dali::Toolkit::ItemId)jarg2;
72889   arg3 = (float)jarg3;
72890   {
72891     try {
72892       (arg1)->ScrollToItem(arg2,arg3);
72893     } catch (std::out_of_range& e) {
72894       {
72895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72896       };
72897     } catch (std::exception& e) {
72898       {
72899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72900       };
72901     } catch (Dali::DaliException e) {
72902       {
72903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72904       };
72905     } catch (...) {
72906       {
72907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72908       };
72909     }
72910   }
72911
72912 }
72913
72914
72915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
72916   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72917   float arg2 ;
72918
72919   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72920   arg2 = (float)jarg2;
72921   {
72922     try {
72923       (arg1)->SetRefreshInterval(arg2);
72924     } catch (std::out_of_range& e) {
72925       {
72926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72927       };
72928     } catch (std::exception& e) {
72929       {
72930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72931       };
72932     } catch (Dali::DaliException e) {
72933       {
72934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72935       };
72936     } catch (...) {
72937       {
72938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72939       };
72940     }
72941   }
72942
72943 }
72944
72945
72946 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
72947   float jresult ;
72948   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72949   float result;
72950
72951   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72952   {
72953     try {
72954       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
72955     } catch (std::out_of_range& e) {
72956       {
72957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72958       };
72959     } catch (std::exception& e) {
72960       {
72961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72962       };
72963     } catch (Dali::DaliException e) {
72964       {
72965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72966       };
72967     } catch (...) {
72968       {
72969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72970       };
72971     }
72972   }
72973
72974   jresult = result;
72975   return jresult;
72976 }
72977
72978
72979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
72980   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72981
72982   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72983   {
72984     try {
72985       (arg1)->Refresh();
72986     } catch (std::out_of_range& e) {
72987       {
72988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72989       };
72990     } catch (std::exception& e) {
72991       {
72992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72993       };
72994     } catch (Dali::DaliException e) {
72995       {
72996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72997       };
72998     } catch (...) {
72999       {
73000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73001       };
73002     }
73003   }
73004
73005 }
73006
73007
73008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
73009   void * jresult ;
73010   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73011   Dali::Toolkit::ItemId arg2 ;
73012   Dali::Actor result;
73013
73014   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73015   arg2 = (Dali::Toolkit::ItemId)jarg2;
73016   {
73017     try {
73018       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
73019     } catch (std::out_of_range& e) {
73020       {
73021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73022       };
73023     } catch (std::exception& e) {
73024       {
73025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73026       };
73027     } catch (Dali::DaliException e) {
73028       {
73029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73030       };
73031     } catch (...) {
73032       {
73033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73034       };
73035     }
73036   }
73037
73038   jresult = new Dali::Actor((const Dali::Actor &)result);
73039   return jresult;
73040 }
73041
73042
73043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
73044   unsigned int jresult ;
73045   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73046   Dali::Actor arg2 ;
73047   Dali::Actor *argp2 ;
73048   Dali::Toolkit::ItemId result;
73049
73050   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73051   argp2 = (Dali::Actor *)jarg2;
73052   if (!argp2) {
73053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73054     return 0;
73055   }
73056   arg2 = *argp2;
73057   {
73058     try {
73059       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
73060     } catch (std::out_of_range& e) {
73061       {
73062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73063       };
73064     } catch (std::exception& e) {
73065       {
73066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73067       };
73068     } catch (Dali::DaliException e) {
73069       {
73070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73071       };
73072     } catch (...) {
73073       {
73074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73075       };
73076     }
73077   }
73078
73079   jresult = result;
73080   return jresult;
73081 }
73082
73083
73084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
73085   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73086   Dali::Toolkit::Item arg2 ;
73087   float arg3 ;
73088   Dali::Toolkit::Item *argp2 ;
73089
73090   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73091   argp2 = (Dali::Toolkit::Item *)jarg2;
73092   if (!argp2) {
73093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
73094     return ;
73095   }
73096   arg2 = *argp2;
73097   arg3 = (float)jarg3;
73098   {
73099     try {
73100       (arg1)->InsertItem(arg2,arg3);
73101     } catch (std::out_of_range& e) {
73102       {
73103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73104       };
73105     } catch (std::exception& e) {
73106       {
73107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73108       };
73109     } catch (Dali::DaliException e) {
73110       {
73111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73112       };
73113     } catch (...) {
73114       {
73115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73116       };
73117     }
73118   }
73119
73120 }
73121
73122
73123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
73124   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73125   Dali::Toolkit::ItemContainer *arg2 = 0 ;
73126   float arg3 ;
73127
73128   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73129   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
73130   if (!arg2) {
73131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
73132     return ;
73133   }
73134   arg3 = (float)jarg3;
73135   {
73136     try {
73137       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
73138     } catch (std::out_of_range& e) {
73139       {
73140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73141       };
73142     } catch (std::exception& e) {
73143       {
73144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73145       };
73146     } catch (Dali::DaliException e) {
73147       {
73148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73149       };
73150     } catch (...) {
73151       {
73152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73153       };
73154     }
73155   }
73156
73157 }
73158
73159
73160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
73161   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73162   Dali::Toolkit::ItemId arg2 ;
73163   float arg3 ;
73164
73165   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73166   arg2 = (Dali::Toolkit::ItemId)jarg2;
73167   arg3 = (float)jarg3;
73168   {
73169     try {
73170       (arg1)->RemoveItem(arg2,arg3);
73171     } catch (std::out_of_range& e) {
73172       {
73173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73174       };
73175     } catch (std::exception& e) {
73176       {
73177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73178       };
73179     } catch (Dali::DaliException e) {
73180       {
73181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73182       };
73183     } catch (...) {
73184       {
73185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73186       };
73187     }
73188   }
73189
73190 }
73191
73192
73193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
73194   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73195   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
73196   float arg3 ;
73197
73198   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73199   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
73200   if (!arg2) {
73201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
73202     return ;
73203   }
73204   arg3 = (float)jarg3;
73205   {
73206     try {
73207       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
73208     } catch (std::out_of_range& e) {
73209       {
73210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73211       };
73212     } catch (std::exception& e) {
73213       {
73214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73215       };
73216     } catch (Dali::DaliException e) {
73217       {
73218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73219       };
73220     } catch (...) {
73221       {
73222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73223       };
73224     }
73225   }
73226
73227 }
73228
73229
73230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
73231   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73232   Dali::Toolkit::Item arg2 ;
73233   float arg3 ;
73234   Dali::Toolkit::Item *argp2 ;
73235
73236   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73237   argp2 = (Dali::Toolkit::Item *)jarg2;
73238   if (!argp2) {
73239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
73240     return ;
73241   }
73242   arg2 = *argp2;
73243   arg3 = (float)jarg3;
73244   {
73245     try {
73246       (arg1)->ReplaceItem(arg2,arg3);
73247     } catch (std::out_of_range& e) {
73248       {
73249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73250       };
73251     } catch (std::exception& e) {
73252       {
73253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73254       };
73255     } catch (Dali::DaliException e) {
73256       {
73257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73258       };
73259     } catch (...) {
73260       {
73261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73262       };
73263     }
73264   }
73265
73266 }
73267
73268
73269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
73270   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73271   Dali::Toolkit::ItemContainer *arg2 = 0 ;
73272   float arg3 ;
73273
73274   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73275   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
73276   if (!arg2) {
73277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
73278     return ;
73279   }
73280   arg3 = (float)jarg3;
73281   {
73282     try {
73283       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
73284     } catch (std::out_of_range& e) {
73285       {
73286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73287       };
73288     } catch (std::exception& e) {
73289       {
73290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73291       };
73292     } catch (Dali::DaliException e) {
73293       {
73294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73295       };
73296     } catch (...) {
73297       {
73298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73299       };
73300     }
73301   }
73302
73303 }
73304
73305
73306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
73307   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73308   Dali::Vector3 *arg2 = 0 ;
73309
73310   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73311   arg2 = (Dali::Vector3 *)jarg2;
73312   if (!arg2) {
73313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73314     return ;
73315   }
73316   {
73317     try {
73318       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
73319     } catch (std::out_of_range& e) {
73320       {
73321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73322       };
73323     } catch (std::exception& e) {
73324       {
73325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73326       };
73327     } catch (Dali::DaliException e) {
73328       {
73329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73330       };
73331     } catch (...) {
73332       {
73333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73334       };
73335     }
73336   }
73337
73338 }
73339
73340
73341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
73342   void * jresult ;
73343   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73344   Dali::Vector3 result;
73345
73346   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73347   {
73348     try {
73349       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
73350     } catch (std::out_of_range& e) {
73351       {
73352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73353       };
73354     } catch (std::exception& e) {
73355       {
73356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73357       };
73358     } catch (Dali::DaliException e) {
73359       {
73360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73361       };
73362     } catch (...) {
73363       {
73364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73365       };
73366     }
73367   }
73368
73369   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
73370   return jresult;
73371 }
73372
73373
73374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
73375   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73376   Dali::Vector3 *arg2 = 0 ;
73377
73378   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73379   arg2 = (Dali::Vector3 *)jarg2;
73380   if (!arg2) {
73381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73382     return ;
73383   }
73384   {
73385     try {
73386       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
73387     } catch (std::out_of_range& e) {
73388       {
73389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73390       };
73391     } catch (std::exception& e) {
73392       {
73393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73394       };
73395     } catch (Dali::DaliException e) {
73396       {
73397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73398       };
73399     } catch (...) {
73400       {
73401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73402       };
73403     }
73404   }
73405
73406 }
73407
73408
73409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
73410   void * jresult ;
73411   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73412   Dali::Vector3 result;
73413
73414   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73415   {
73416     try {
73417       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
73418     } catch (std::out_of_range& e) {
73419       {
73420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73421       };
73422     } catch (std::exception& e) {
73423       {
73424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73425       };
73426     } catch (Dali::DaliException e) {
73427       {
73428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73429       };
73430     } catch (...) {
73431       {
73432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73433       };
73434     }
73435   }
73436
73437   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
73438   return jresult;
73439 }
73440
73441
73442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
73443   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73444   Dali::Toolkit::ItemRange *arg2 = 0 ;
73445
73446   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73447   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73448   if (!arg2) {
73449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
73450     return ;
73451   }
73452   {
73453     try {
73454       (arg1)->GetItemsRange(*arg2);
73455     } catch (std::out_of_range& e) {
73456       {
73457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73458       };
73459     } catch (std::exception& e) {
73460       {
73461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73462       };
73463     } catch (Dali::DaliException e) {
73464       {
73465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73466       };
73467     } catch (...) {
73468       {
73469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73470       };
73471     }
73472   }
73473
73474 }
73475
73476
73477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
73478   void * jresult ;
73479   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73480   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
73481
73482   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73483   {
73484     try {
73485       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
73486     } catch (std::out_of_range& e) {
73487       {
73488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73489       };
73490     } catch (std::exception& e) {
73491       {
73492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73493       };
73494     } catch (Dali::DaliException e) {
73495       {
73496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73497       };
73498     } catch (...) {
73499       {
73500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73501       };
73502     }
73503   }
73504
73505   jresult = (void *)result;
73506   return jresult;
73507 }
73508
73509
73510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
73511   Dali::Vector3 *arg1 = 0 ;
73512   PropertyInputContainer *arg2 = 0 ;
73513
73514   arg1 = (Dali::Vector3 *)jarg1;
73515   if (!arg1) {
73516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73517     return ;
73518   }
73519   arg2 = (PropertyInputContainer *)jarg2;
73520   if (!arg2) {
73521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
73522     return ;
73523   }
73524   {
73525     try {
73526       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
73527     } catch (std::out_of_range& e) {
73528       {
73529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73530       };
73531     } catch (std::exception& e) {
73532       {
73533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73534       };
73535     } catch (Dali::DaliException e) {
73536       {
73537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73538       };
73539     } catch (...) {
73540       {
73541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73542       };
73543     }
73544   }
73545
73546 }
73547
73548
73549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
73550   Dali::Vector3 *arg1 = 0 ;
73551   PropertyInputContainer *arg2 = 0 ;
73552
73553   arg1 = (Dali::Vector3 *)jarg1;
73554   if (!arg1) {
73555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73556     return ;
73557   }
73558   arg2 = (PropertyInputContainer *)jarg2;
73559   if (!arg2) {
73560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
73561     return ;
73562   }
73563   {
73564     try {
73565       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
73566     } catch (std::out_of_range& e) {
73567       {
73568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73569       };
73570     } catch (std::exception& e) {
73571       {
73572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73573       };
73574     } catch (Dali::DaliException e) {
73575       {
73576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73577       };
73578     } catch (...) {
73579       {
73580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73581       };
73582     }
73583   }
73584
73585 }
73586
73587
73588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
73589   void * jresult ;
73590   Dali::Toolkit::ScrollViewEffect *result = 0 ;
73591
73592   {
73593     try {
73594       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
73595     } catch (std::out_of_range& e) {
73596       {
73597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73598       };
73599     } catch (std::exception& e) {
73600       {
73601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73602       };
73603     } catch (Dali::DaliException e) {
73604       {
73605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73606       };
73607     } catch (...) {
73608       {
73609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73610       };
73611     }
73612   }
73613
73614   jresult = (void *)result;
73615   return jresult;
73616 }
73617
73618
73619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
73620   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
73621
73622   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
73623   {
73624     try {
73625       delete arg1;
73626     } catch (std::out_of_range& e) {
73627       {
73628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73629       };
73630     } catch (std::exception& e) {
73631       {
73632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73633       };
73634     } catch (Dali::DaliException e) {
73635       {
73636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73637       };
73638     } catch (...) {
73639       {
73640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73641       };
73642     }
73643   }
73644
73645 }
73646
73647
73648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
73649   void * jresult ;
73650   Dali::Path arg1 ;
73651   Dali::Vector3 *arg2 = 0 ;
73652   Dali::Property::Index arg3 ;
73653   Dali::Vector3 *arg4 = 0 ;
73654   unsigned int arg5 ;
73655   Dali::Path *argp1 ;
73656   Dali::Toolkit::ScrollViewPagePathEffect result;
73657
73658   argp1 = (Dali::Path *)jarg1;
73659   if (!argp1) {
73660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
73661     return 0;
73662   }
73663   arg1 = *argp1;
73664   arg2 = (Dali::Vector3 *)jarg2;
73665   if (!arg2) {
73666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73667     return 0;
73668   }
73669   arg3 = (Dali::Property::Index)jarg3;
73670   arg4 = (Dali::Vector3 *)jarg4;
73671   if (!arg4) {
73672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73673     return 0;
73674   }
73675   arg5 = (unsigned int)jarg5;
73676   {
73677     try {
73678       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
73679     } catch (std::out_of_range& e) {
73680       {
73681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73682       };
73683     } catch (std::exception& e) {
73684       {
73685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73686       };
73687     } catch (Dali::DaliException e) {
73688       {
73689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73690       };
73691     } catch (...) {
73692       {
73693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73694       };
73695     }
73696   }
73697
73698   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
73699   return jresult;
73700 }
73701
73702
73703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
73704   void * jresult ;
73705   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
73706
73707   {
73708     try {
73709       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
73710     } catch (std::out_of_range& e) {
73711       {
73712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73713       };
73714     } catch (std::exception& e) {
73715       {
73716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73717       };
73718     } catch (Dali::DaliException e) {
73719       {
73720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73721       };
73722     } catch (...) {
73723       {
73724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73725       };
73726     }
73727   }
73728
73729   jresult = (void *)result;
73730   return jresult;
73731 }
73732
73733
73734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
73735   void * jresult ;
73736   Dali::BaseHandle arg1 ;
73737   Dali::BaseHandle *argp1 ;
73738   Dali::Toolkit::ScrollViewPagePathEffect result;
73739
73740   argp1 = (Dali::BaseHandle *)jarg1;
73741   if (!argp1) {
73742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73743     return 0;
73744   }
73745   arg1 = *argp1;
73746   {
73747     try {
73748       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
73749     } catch (std::out_of_range& e) {
73750       {
73751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73752       };
73753     } catch (std::exception& e) {
73754       {
73755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73756       };
73757     } catch (Dali::DaliException e) {
73758       {
73759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73760       };
73761     } catch (...) {
73762       {
73763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73764       };
73765     }
73766   }
73767
73768   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
73769   return jresult;
73770 }
73771
73772
73773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
73774   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
73775   Dali::Actor arg2 ;
73776   unsigned int arg3 ;
73777   Dali::Actor *argp2 ;
73778
73779   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
73780   argp2 = (Dali::Actor *)jarg2;
73781   if (!argp2) {
73782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73783     return ;
73784   }
73785   arg2 = *argp2;
73786   arg3 = (unsigned int)jarg3;
73787   {
73788     try {
73789       (arg1)->ApplyToPage(arg2,arg3);
73790     } catch (std::out_of_range& e) {
73791       {
73792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73793       };
73794     } catch (std::exception& e) {
73795       {
73796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73797       };
73798     } catch (Dali::DaliException e) {
73799       {
73800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73801       };
73802     } catch (...) {
73803       {
73804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73805       };
73806     }
73807   }
73808
73809 }
73810
73811
73812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
73813   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
73814
73815   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
73816   {
73817     try {
73818       delete arg1;
73819     } catch (std::out_of_range& e) {
73820       {
73821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73822       };
73823     } catch (std::exception& e) {
73824       {
73825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73826       };
73827     } catch (Dali::DaliException e) {
73828       {
73829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73830       };
73831     } catch (...) {
73832       {
73833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73834       };
73835     }
73836   }
73837
73838 }
73839
73840
73841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
73842   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
73843   Dali::Toolkit::ClampState arg2 ;
73844
73845   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
73846   arg2 = (Dali::Toolkit::ClampState)jarg2;
73847   if (arg1) (arg1)->x = arg2;
73848 }
73849
73850
73851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
73852   int jresult ;
73853   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
73854   Dali::Toolkit::ClampState result;
73855
73856   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
73857   result = (Dali::Toolkit::ClampState) ((arg1)->x);
73858   jresult = (int)result;
73859   return jresult;
73860 }
73861
73862
73863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
73864   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
73865   Dali::Toolkit::ClampState arg2 ;
73866
73867   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
73868   arg2 = (Dali::Toolkit::ClampState)jarg2;
73869   if (arg1) (arg1)->y = arg2;
73870 }
73871
73872
73873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
73874   int jresult ;
73875   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
73876   Dali::Toolkit::ClampState result;
73877
73878   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
73879   result = (Dali::Toolkit::ClampState) ((arg1)->y);
73880   jresult = (int)result;
73881   return jresult;
73882 }
73883
73884
73885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
73886   void * jresult ;
73887   Dali::Toolkit::ClampState2D *result = 0 ;
73888
73889   {
73890     try {
73891       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
73892     } catch (std::out_of_range& e) {
73893       {
73894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73895       };
73896     } catch (std::exception& e) {
73897       {
73898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73899       };
73900     } catch (Dali::DaliException e) {
73901       {
73902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73903       };
73904     } catch (...) {
73905       {
73906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73907       };
73908     }
73909   }
73910
73911   jresult = (void *)result;
73912   return jresult;
73913 }
73914
73915
73916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
73917   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
73918
73919   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
73920   {
73921     try {
73922       delete arg1;
73923     } catch (std::out_of_range& e) {
73924       {
73925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73926       };
73927     } catch (std::exception& e) {
73928       {
73929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73930       };
73931     } catch (Dali::DaliException e) {
73932       {
73933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73934       };
73935     } catch (...) {
73936       {
73937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73938       };
73939     }
73940   }
73941
73942 }
73943
73944
73945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
73946   void * jresult ;
73947   float arg1 ;
73948   float arg2 ;
73949   bool arg3 ;
73950   Dali::Toolkit::RulerDomain *result = 0 ;
73951
73952   arg1 = (float)jarg1;
73953   arg2 = (float)jarg2;
73954   arg3 = jarg3 ? true : false;
73955   {
73956     try {
73957       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
73958     } catch (std::out_of_range& e) {
73959       {
73960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73961       };
73962     } catch (std::exception& e) {
73963       {
73964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73965       };
73966     } catch (Dali::DaliException e) {
73967       {
73968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73969       };
73970     } catch (...) {
73971       {
73972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73973       };
73974     }
73975   }
73976
73977   jresult = (void *)result;
73978   return jresult;
73979 }
73980
73981
73982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
73983   void * jresult ;
73984   float arg1 ;
73985   float arg2 ;
73986   Dali::Toolkit::RulerDomain *result = 0 ;
73987
73988   arg1 = (float)jarg1;
73989   arg2 = (float)jarg2;
73990   {
73991     try {
73992       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
73993     } catch (std::out_of_range& e) {
73994       {
73995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73996       };
73997     } catch (std::exception& e) {
73998       {
73999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74000       };
74001     } catch (Dali::DaliException e) {
74002       {
74003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74004       };
74005     } catch (...) {
74006       {
74007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74008       };
74009     }
74010   }
74011
74012   jresult = (void *)result;
74013   return jresult;
74014 }
74015
74016
74017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
74018   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74019   float arg2 ;
74020
74021   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74022   arg2 = (float)jarg2;
74023   if (arg1) (arg1)->min = arg2;
74024 }
74025
74026
74027 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
74028   float jresult ;
74029   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74030   float result;
74031
74032   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74033   result = (float) ((arg1)->min);
74034   jresult = result;
74035   return jresult;
74036 }
74037
74038
74039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
74040   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74041   float arg2 ;
74042
74043   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74044   arg2 = (float)jarg2;
74045   if (arg1) (arg1)->max = arg2;
74046 }
74047
74048
74049 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
74050   float jresult ;
74051   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74052   float result;
74053
74054   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74055   result = (float) ((arg1)->max);
74056   jresult = result;
74057   return jresult;
74058 }
74059
74060
74061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
74062   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74063   bool arg2 ;
74064
74065   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74066   arg2 = jarg2 ? true : false;
74067   if (arg1) (arg1)->enabled = arg2;
74068 }
74069
74070
74071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
74072   unsigned int jresult ;
74073   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74074   bool result;
74075
74076   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74077   result = (bool) ((arg1)->enabled);
74078   jresult = result;
74079   return jresult;
74080 }
74081
74082
74083 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
74084   float jresult ;
74085   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74086   float arg2 ;
74087   float arg3 ;
74088   float arg4 ;
74089   float result;
74090
74091   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74092   arg2 = (float)jarg2;
74093   arg3 = (float)jarg3;
74094   arg4 = (float)jarg4;
74095   {
74096     try {
74097       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
74098     } catch (std::out_of_range& e) {
74099       {
74100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74101       };
74102     } catch (std::exception& e) {
74103       {
74104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74105       };
74106     } catch (Dali::DaliException e) {
74107       {
74108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74109       };
74110     } catch (...) {
74111       {
74112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74113       };
74114     }
74115   }
74116
74117   jresult = result;
74118   return jresult;
74119 }
74120
74121
74122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
74123   float jresult ;
74124   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74125   float arg2 ;
74126   float arg3 ;
74127   float result;
74128
74129   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74130   arg2 = (float)jarg2;
74131   arg3 = (float)jarg3;
74132   {
74133     try {
74134       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
74135     } catch (std::out_of_range& e) {
74136       {
74137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74138       };
74139     } catch (std::exception& e) {
74140       {
74141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74142       };
74143     } catch (Dali::DaliException e) {
74144       {
74145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74146       };
74147     } catch (...) {
74148       {
74149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74150       };
74151     }
74152   }
74153
74154   jresult = result;
74155   return jresult;
74156 }
74157
74158
74159 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
74160   float jresult ;
74161   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74162   float arg2 ;
74163   float result;
74164
74165   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74166   arg2 = (float)jarg2;
74167   {
74168     try {
74169       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
74170     } catch (std::out_of_range& e) {
74171       {
74172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74173       };
74174     } catch (std::exception& e) {
74175       {
74176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74177       };
74178     } catch (Dali::DaliException e) {
74179       {
74180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74181       };
74182     } catch (...) {
74183       {
74184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74185       };
74186     }
74187   }
74188
74189   jresult = result;
74190   return jresult;
74191 }
74192
74193
74194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
74195   float jresult ;
74196   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74197   float arg2 ;
74198   float arg3 ;
74199   float arg4 ;
74200   Dali::Toolkit::ClampState *arg5 = 0 ;
74201   float result;
74202
74203   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74204   arg2 = (float)jarg2;
74205   arg3 = (float)jarg3;
74206   arg4 = (float)jarg4;
74207   arg5 = (Dali::Toolkit::ClampState *)jarg5;
74208   if (!arg5) {
74209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
74210     return 0;
74211   }
74212   {
74213     try {
74214       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
74215     } catch (std::out_of_range& e) {
74216       {
74217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74218       };
74219     } catch (std::exception& e) {
74220       {
74221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74222       };
74223     } catch (Dali::DaliException e) {
74224       {
74225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74226       };
74227     } catch (...) {
74228       {
74229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74230       };
74231     }
74232   }
74233
74234   jresult = result;
74235   return jresult;
74236 }
74237
74238
74239 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
74240   float jresult ;
74241   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74242   float result;
74243
74244   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74245   {
74246     try {
74247       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
74248     } catch (std::out_of_range& e) {
74249       {
74250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74251       };
74252     } catch (std::exception& e) {
74253       {
74254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74255       };
74256     } catch (Dali::DaliException e) {
74257       {
74258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74259       };
74260     } catch (...) {
74261       {
74262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74263       };
74264     }
74265   }
74266
74267   jresult = result;
74268   return jresult;
74269 }
74270
74271
74272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
74273   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74274
74275   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74276   {
74277     try {
74278       delete arg1;
74279     } catch (std::out_of_range& e) {
74280       {
74281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74282       };
74283     } catch (std::exception& e) {
74284       {
74285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74286       };
74287     } catch (Dali::DaliException e) {
74288       {
74289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74290       };
74291     } catch (...) {
74292       {
74293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74294       };
74295     }
74296   }
74297
74298 }
74299
74300
74301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
74302   float jresult ;
74303   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74304   float arg2 ;
74305   float arg3 ;
74306   float result;
74307
74308   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74309   arg2 = (float)jarg2;
74310   arg3 = (float)jarg3;
74311   {
74312     try {
74313       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
74314     } catch (std::out_of_range& e) {
74315       {
74316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74317       };
74318     } catch (std::exception& e) {
74319       {
74320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74321       };
74322     } catch (Dali::DaliException e) {
74323       {
74324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74325       };
74326     } catch (...) {
74327       {
74328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74329       };
74330     }
74331   }
74332
74333   jresult = result;
74334   return jresult;
74335 }
74336
74337
74338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
74339   float jresult ;
74340   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74341   float arg2 ;
74342   float result;
74343
74344   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74345   arg2 = (float)jarg2;
74346   {
74347     try {
74348       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
74349     } catch (std::out_of_range& e) {
74350       {
74351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74352       };
74353     } catch (std::exception& e) {
74354       {
74355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74356       };
74357     } catch (Dali::DaliException e) {
74358       {
74359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74360       };
74361     } catch (...) {
74362       {
74363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74364       };
74365     }
74366   }
74367
74368   jresult = result;
74369   return jresult;
74370 }
74371
74372
74373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
74374   float jresult ;
74375   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74376   unsigned int arg2 ;
74377   unsigned int *arg3 = 0 ;
74378   bool arg4 ;
74379   float result;
74380
74381   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74382   arg2 = (unsigned int)jarg2;
74383   arg3 = (unsigned int *)jarg3;
74384   arg4 = jarg4 ? true : false;
74385   {
74386     try {
74387       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
74388     } catch (std::out_of_range& e) {
74389       {
74390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74391       };
74392     } catch (std::exception& e) {
74393       {
74394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74395       };
74396     } catch (Dali::DaliException e) {
74397       {
74398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74399       };
74400     } catch (...) {
74401       {
74402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74403       };
74404     }
74405   }
74406
74407   jresult = result;
74408   return jresult;
74409 }
74410
74411
74412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
74413   unsigned int jresult ;
74414   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74415   float arg2 ;
74416   bool arg3 ;
74417   unsigned int result;
74418
74419   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74420   arg2 = (float)jarg2;
74421   arg3 = jarg3 ? true : false;
74422   {
74423     try {
74424       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
74425     } catch (std::out_of_range& e) {
74426       {
74427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74428       };
74429     } catch (std::exception& e) {
74430       {
74431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74432       };
74433     } catch (Dali::DaliException e) {
74434       {
74435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74436       };
74437     } catch (...) {
74438       {
74439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74440       };
74441     }
74442   }
74443
74444   jresult = result;
74445   return jresult;
74446 }
74447
74448
74449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
74450   unsigned int jresult ;
74451   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74452   unsigned int result;
74453
74454   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74455   {
74456     try {
74457       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
74458     } catch (std::out_of_range& e) {
74459       {
74460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74461       };
74462     } catch (std::exception& e) {
74463       {
74464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74465       };
74466     } catch (Dali::DaliException e) {
74467       {
74468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74469       };
74470     } catch (...) {
74471       {
74472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74473       };
74474     }
74475   }
74476
74477   jresult = result;
74478   return jresult;
74479 }
74480
74481
74482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
74483   int jresult ;
74484   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74485   Dali::Toolkit::Ruler::RulerType result;
74486
74487   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74488   {
74489     try {
74490       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
74491     } catch (std::out_of_range& e) {
74492       {
74493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74494       };
74495     } catch (std::exception& e) {
74496       {
74497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74498       };
74499     } catch (Dali::DaliException e) {
74500       {
74501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74502       };
74503     } catch (...) {
74504       {
74505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74506       };
74507     }
74508   }
74509
74510   jresult = (int)result;
74511   return jresult;
74512 }
74513
74514
74515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
74516   unsigned int jresult ;
74517   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74518   bool result;
74519
74520   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74521   {
74522     try {
74523       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
74524     } catch (std::out_of_range& e) {
74525       {
74526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74527       };
74528     } catch (std::exception& e) {
74529       {
74530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74531       };
74532     } catch (Dali::DaliException e) {
74533       {
74534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74535       };
74536     } catch (...) {
74537       {
74538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74539       };
74540     }
74541   }
74542
74543   jresult = result;
74544   return jresult;
74545 }
74546
74547
74548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
74549   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74550
74551   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74552   {
74553     try {
74554       (arg1)->Enable();
74555     } catch (std::out_of_range& e) {
74556       {
74557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74558       };
74559     } catch (std::exception& e) {
74560       {
74561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74562       };
74563     } catch (Dali::DaliException e) {
74564       {
74565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74566       };
74567     } catch (...) {
74568       {
74569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74570       };
74571     }
74572   }
74573
74574 }
74575
74576
74577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
74578   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74579
74580   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74581   {
74582     try {
74583       (arg1)->Disable();
74584     } catch (std::out_of_range& e) {
74585       {
74586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74587       };
74588     } catch (std::exception& e) {
74589       {
74590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74591       };
74592     } catch (Dali::DaliException e) {
74593       {
74594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74595       };
74596     } catch (...) {
74597       {
74598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74599       };
74600     }
74601   }
74602
74603 }
74604
74605
74606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
74607   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74608   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
74609   Dali::Toolkit::RulerDomain *argp2 ;
74610
74611   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74612   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
74613   if (!argp2) {
74614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
74615     return ;
74616   }
74617   arg2 = *argp2;
74618   {
74619     try {
74620       (arg1)->SetDomain(arg2);
74621     } catch (std::out_of_range& e) {
74622       {
74623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74624       };
74625     } catch (std::exception& e) {
74626       {
74627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74628       };
74629     } catch (Dali::DaliException e) {
74630       {
74631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74632       };
74633     } catch (...) {
74634       {
74635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74636       };
74637     }
74638   }
74639
74640 }
74641
74642
74643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
74644   void * jresult ;
74645   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74646   Dali::Toolkit::RulerDomain *result = 0 ;
74647
74648   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74649   {
74650     try {
74651       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
74652     } catch (std::out_of_range& e) {
74653       {
74654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74655       };
74656     } catch (std::exception& e) {
74657       {
74658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74659       };
74660     } catch (Dali::DaliException e) {
74661       {
74662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74663       };
74664     } catch (...) {
74665       {
74666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74667       };
74668     }
74669   }
74670
74671   jresult = (void *)result;
74672   return jresult;
74673 }
74674
74675
74676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
74677   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74678
74679   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74680   {
74681     try {
74682       (arg1)->DisableDomain();
74683     } catch (std::out_of_range& e) {
74684       {
74685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74686       };
74687     } catch (std::exception& e) {
74688       {
74689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74690       };
74691     } catch (Dali::DaliException e) {
74692       {
74693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74694       };
74695     } catch (...) {
74696       {
74697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74698       };
74699     }
74700   }
74701
74702 }
74703
74704
74705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
74706   float jresult ;
74707   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74708   float arg2 ;
74709   float arg3 ;
74710   float arg4 ;
74711   float result;
74712
74713   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74714   arg2 = (float)jarg2;
74715   arg3 = (float)jarg3;
74716   arg4 = (float)jarg4;
74717   {
74718     try {
74719       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
74720     } catch (std::out_of_range& e) {
74721       {
74722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74723       };
74724     } catch (std::exception& e) {
74725       {
74726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74727       };
74728     } catch (Dali::DaliException e) {
74729       {
74730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74731       };
74732     } catch (...) {
74733       {
74734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74735       };
74736     }
74737   }
74738
74739   jresult = result;
74740   return jresult;
74741 }
74742
74743
74744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
74745   float jresult ;
74746   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74747   float arg2 ;
74748   float arg3 ;
74749   float result;
74750
74751   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74752   arg2 = (float)jarg2;
74753   arg3 = (float)jarg3;
74754   {
74755     try {
74756       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
74757     } catch (std::out_of_range& e) {
74758       {
74759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74760       };
74761     } catch (std::exception& e) {
74762       {
74763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74764       };
74765     } catch (Dali::DaliException e) {
74766       {
74767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74768       };
74769     } catch (...) {
74770       {
74771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74772       };
74773     }
74774   }
74775
74776   jresult = result;
74777   return jresult;
74778 }
74779
74780
74781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
74782   float jresult ;
74783   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74784   float arg2 ;
74785   float result;
74786
74787   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74788   arg2 = (float)jarg2;
74789   {
74790     try {
74791       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
74792     } catch (std::out_of_range& e) {
74793       {
74794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74795       };
74796     } catch (std::exception& e) {
74797       {
74798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74799       };
74800     } catch (Dali::DaliException e) {
74801       {
74802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74803       };
74804     } catch (...) {
74805       {
74806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74807       };
74808     }
74809   }
74810
74811   jresult = result;
74812   return jresult;
74813 }
74814
74815
74816 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
74817   float jresult ;
74818   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74819   float arg2 ;
74820   float arg3 ;
74821   float arg4 ;
74822   Dali::Toolkit::ClampState *arg5 = 0 ;
74823   float result;
74824
74825   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74826   arg2 = (float)jarg2;
74827   arg3 = (float)jarg3;
74828   arg4 = (float)jarg4;
74829   arg5 = (Dali::Toolkit::ClampState *)jarg5;
74830   if (!arg5) {
74831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
74832     return 0;
74833   }
74834   {
74835     try {
74836       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
74837     } catch (std::out_of_range& e) {
74838       {
74839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74840       };
74841     } catch (std::exception& e) {
74842       {
74843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74844       };
74845     } catch (Dali::DaliException e) {
74846       {
74847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74848       };
74849     } catch (...) {
74850       {
74851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74852       };
74853     }
74854   }
74855
74856   jresult = result;
74857   return jresult;
74858 }
74859
74860
74861 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
74862   float jresult ;
74863   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74864   float arg2 ;
74865   float arg3 ;
74866   float arg4 ;
74867   float arg5 ;
74868   float result;
74869
74870   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74871   arg2 = (float)jarg2;
74872   arg3 = (float)jarg3;
74873   arg4 = (float)jarg4;
74874   arg5 = (float)jarg5;
74875   {
74876     try {
74877       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
74878     } catch (std::out_of_range& e) {
74879       {
74880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74881       };
74882     } catch (std::exception& e) {
74883       {
74884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74885       };
74886     } catch (Dali::DaliException e) {
74887       {
74888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74889       };
74890     } catch (...) {
74891       {
74892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74893       };
74894     }
74895   }
74896
74897   jresult = result;
74898   return jresult;
74899 }
74900
74901
74902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
74903   float jresult ;
74904   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74905   float arg2 ;
74906   float arg3 ;
74907   float arg4 ;
74908   float result;
74909
74910   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74911   arg2 = (float)jarg2;
74912   arg3 = (float)jarg3;
74913   arg4 = (float)jarg4;
74914   {
74915     try {
74916       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
74917     } catch (std::out_of_range& e) {
74918       {
74919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74920       };
74921     } catch (std::exception& e) {
74922       {
74923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74924       };
74925     } catch (Dali::DaliException e) {
74926       {
74927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74928       };
74929     } catch (...) {
74930       {
74931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74932       };
74933     }
74934   }
74935
74936   jresult = result;
74937   return jresult;
74938 }
74939
74940
74941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
74942   float jresult ;
74943   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74944   float arg2 ;
74945   float arg3 ;
74946   float result;
74947
74948   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74949   arg2 = (float)jarg2;
74950   arg3 = (float)jarg3;
74951   {
74952     try {
74953       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
74954     } catch (std::out_of_range& e) {
74955       {
74956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74957       };
74958     } catch (std::exception& e) {
74959       {
74960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74961       };
74962     } catch (Dali::DaliException e) {
74963       {
74964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74965       };
74966     } catch (...) {
74967       {
74968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74969       };
74970     }
74971   }
74972
74973   jresult = result;
74974   return jresult;
74975 }
74976
74977
74978 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
74979   float jresult ;
74980   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74981   float arg2 ;
74982   float result;
74983
74984   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74985   arg2 = (float)jarg2;
74986   {
74987     try {
74988       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
74989     } catch (std::out_of_range& e) {
74990       {
74991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74992       };
74993     } catch (std::exception& e) {
74994       {
74995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74996       };
74997     } catch (Dali::DaliException e) {
74998       {
74999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75000       };
75001     } catch (...) {
75002       {
75003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75004       };
75005     }
75006   }
75007
75008   jresult = result;
75009   return jresult;
75010 }
75011
75012
75013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
75014   float jresult ;
75015   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75016   float arg2 ;
75017   float arg3 ;
75018   float arg4 ;
75019   float arg5 ;
75020   Dali::Toolkit::ClampState *arg6 = 0 ;
75021   float result;
75022
75023   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75024   arg2 = (float)jarg2;
75025   arg3 = (float)jarg3;
75026   arg4 = (float)jarg4;
75027   arg5 = (float)jarg5;
75028   arg6 = (Dali::Toolkit::ClampState *)jarg6;
75029   if (!arg6) {
75030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
75031     return 0;
75032   }
75033   {
75034     try {
75035       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
75036     } catch (std::out_of_range& e) {
75037       {
75038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75039       };
75040     } catch (std::exception& e) {
75041       {
75042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75043       };
75044     } catch (Dali::DaliException e) {
75045       {
75046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75047       };
75048     } catch (...) {
75049       {
75050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75051       };
75052     }
75053   }
75054
75055   jresult = result;
75056   return jresult;
75057 }
75058
75059
75060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
75061   void * jresult ;
75062   Dali::Toolkit::DefaultRuler *result = 0 ;
75063
75064   {
75065     try {
75066       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
75067     } catch (std::out_of_range& e) {
75068       {
75069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75070       };
75071     } catch (std::exception& e) {
75072       {
75073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75074       };
75075     } catch (Dali::DaliException e) {
75076       {
75077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75078       };
75079     } catch (...) {
75080       {
75081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75082       };
75083     }
75084   }
75085
75086   jresult = (void *)result;
75087   return jresult;
75088 }
75089
75090
75091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
75092   float jresult ;
75093   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
75094   float arg2 ;
75095   float arg3 ;
75096   float result;
75097
75098   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
75099   arg2 = (float)jarg2;
75100   arg3 = (float)jarg3;
75101   {
75102     try {
75103       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
75104     } catch (std::out_of_range& e) {
75105       {
75106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75107       };
75108     } catch (std::exception& e) {
75109       {
75110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75111       };
75112     } catch (Dali::DaliException e) {
75113       {
75114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75115       };
75116     } catch (...) {
75117       {
75118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75119       };
75120     }
75121   }
75122
75123   jresult = result;
75124   return jresult;
75125 }
75126
75127
75128 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
75129   float jresult ;
75130   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
75131   unsigned int arg2 ;
75132   unsigned int *arg3 = 0 ;
75133   bool arg4 ;
75134   float result;
75135
75136   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
75137   arg2 = (unsigned int)jarg2;
75138   arg3 = (unsigned int *)jarg3;
75139   arg4 = jarg4 ? true : false;
75140   {
75141     try {
75142       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
75143     } catch (std::out_of_range& e) {
75144       {
75145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75146       };
75147     } catch (std::exception& e) {
75148       {
75149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75150       };
75151     } catch (Dali::DaliException e) {
75152       {
75153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75154       };
75155     } catch (...) {
75156       {
75157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75158       };
75159     }
75160   }
75161
75162   jresult = result;
75163   return jresult;
75164 }
75165
75166
75167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
75168   unsigned int jresult ;
75169   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
75170   float arg2 ;
75171   bool arg3 ;
75172   unsigned int result;
75173
75174   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
75175   arg2 = (float)jarg2;
75176   arg3 = jarg3 ? true : false;
75177   {
75178     try {
75179       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
75180     } catch (std::out_of_range& e) {
75181       {
75182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75183       };
75184     } catch (std::exception& e) {
75185       {
75186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75187       };
75188     } catch (Dali::DaliException e) {
75189       {
75190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75191       };
75192     } catch (...) {
75193       {
75194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75195       };
75196     }
75197   }
75198
75199   jresult = result;
75200   return jresult;
75201 }
75202
75203
75204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
75205   unsigned int jresult ;
75206   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
75207   unsigned int result;
75208
75209   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
75210   {
75211     try {
75212       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
75213     } catch (std::out_of_range& e) {
75214       {
75215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75216       };
75217     } catch (std::exception& e) {
75218       {
75219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75220       };
75221     } catch (Dali::DaliException e) {
75222       {
75223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75224       };
75225     } catch (...) {
75226       {
75227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75228       };
75229     }
75230   }
75231
75232   jresult = result;
75233   return jresult;
75234 }
75235
75236
75237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
75238   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
75239
75240   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
75241   {
75242     try {
75243       delete arg1;
75244     } catch (std::out_of_range& e) {
75245       {
75246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75247       };
75248     } catch (std::exception& e) {
75249       {
75250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75251       };
75252     } catch (Dali::DaliException e) {
75253       {
75254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75255       };
75256     } catch (...) {
75257       {
75258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75259       };
75260     }
75261   }
75262
75263 }
75264
75265
75266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
75267   void * jresult ;
75268   float arg1 ;
75269   Dali::Toolkit::FixedRuler *result = 0 ;
75270
75271   arg1 = (float)jarg1;
75272   {
75273     try {
75274       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
75275     } catch (std::out_of_range& e) {
75276       {
75277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75278       };
75279     } catch (std::exception& e) {
75280       {
75281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75282       };
75283     } catch (Dali::DaliException e) {
75284       {
75285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75286       };
75287     } catch (...) {
75288       {
75289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75290       };
75291     }
75292   }
75293
75294   jresult = (void *)result;
75295   return jresult;
75296 }
75297
75298
75299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
75300   void * jresult ;
75301   Dali::Toolkit::FixedRuler *result = 0 ;
75302
75303   {
75304     try {
75305       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
75306     } catch (std::out_of_range& e) {
75307       {
75308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75309       };
75310     } catch (std::exception& e) {
75311       {
75312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75313       };
75314     } catch (Dali::DaliException e) {
75315       {
75316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75317       };
75318     } catch (...) {
75319       {
75320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75321       };
75322     }
75323   }
75324
75325   jresult = (void *)result;
75326   return jresult;
75327 }
75328
75329
75330 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
75331   float jresult ;
75332   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
75333   float arg2 ;
75334   float arg3 ;
75335   float result;
75336
75337   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
75338   arg2 = (float)jarg2;
75339   arg3 = (float)jarg3;
75340   {
75341     try {
75342       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
75343     } catch (std::out_of_range& e) {
75344       {
75345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75346       };
75347     } catch (std::exception& e) {
75348       {
75349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75350       };
75351     } catch (Dali::DaliException e) {
75352       {
75353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75354       };
75355     } catch (...) {
75356       {
75357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75358       };
75359     }
75360   }
75361
75362   jresult = result;
75363   return jresult;
75364 }
75365
75366
75367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
75368   float jresult ;
75369   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
75370   unsigned int arg2 ;
75371   unsigned int *arg3 = 0 ;
75372   bool arg4 ;
75373   float result;
75374
75375   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
75376   arg2 = (unsigned int)jarg2;
75377   arg3 = (unsigned int *)jarg3;
75378   arg4 = jarg4 ? true : false;
75379   {
75380     try {
75381       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
75382     } catch (std::out_of_range& e) {
75383       {
75384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75385       };
75386     } catch (std::exception& e) {
75387       {
75388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75389       };
75390     } catch (Dali::DaliException e) {
75391       {
75392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75393       };
75394     } catch (...) {
75395       {
75396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75397       };
75398     }
75399   }
75400
75401   jresult = result;
75402   return jresult;
75403 }
75404
75405
75406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
75407   unsigned int jresult ;
75408   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
75409   float arg2 ;
75410   bool arg3 ;
75411   unsigned int result;
75412
75413   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
75414   arg2 = (float)jarg2;
75415   arg3 = jarg3 ? true : false;
75416   {
75417     try {
75418       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
75419     } catch (std::out_of_range& e) {
75420       {
75421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75422       };
75423     } catch (std::exception& e) {
75424       {
75425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75426       };
75427     } catch (Dali::DaliException e) {
75428       {
75429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75430       };
75431     } catch (...) {
75432       {
75433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75434       };
75435     }
75436   }
75437
75438   jresult = result;
75439   return jresult;
75440 }
75441
75442
75443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
75444   unsigned int jresult ;
75445   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
75446   unsigned int result;
75447
75448   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
75449   {
75450     try {
75451       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
75452     } catch (std::out_of_range& e) {
75453       {
75454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75455       };
75456     } catch (std::exception& e) {
75457       {
75458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75459       };
75460     } catch (Dali::DaliException e) {
75461       {
75462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75463       };
75464     } catch (...) {
75465       {
75466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75467       };
75468     }
75469   }
75470
75471   jresult = result;
75472   return jresult;
75473 }
75474
75475
75476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
75477   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
75478
75479   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
75480   {
75481     try {
75482       delete arg1;
75483     } catch (std::out_of_range& e) {
75484       {
75485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75486       };
75487     } catch (std::exception& e) {
75488       {
75489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75490       };
75491     } catch (Dali::DaliException e) {
75492       {
75493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75494       };
75495     } catch (...) {
75496       {
75497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75498       };
75499     }
75500   }
75501
75502 }
75503
75504
75505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
75506   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
75507   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
75508
75509   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
75510   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
75511   if (arg1) (arg1)->scale = *arg2;
75512 }
75513
75514
75515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
75516   void * jresult ;
75517   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
75518   Dali::Toolkit::ClampState2D *result = 0 ;
75519
75520   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
75521   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
75522   jresult = (void *)result;
75523   return jresult;
75524 }
75525
75526
75527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
75528   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
75529   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
75530
75531   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
75532   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
75533   if (arg1) (arg1)->position = *arg2;
75534 }
75535
75536
75537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
75538   void * jresult ;
75539   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
75540   Dali::Toolkit::ClampState2D *result = 0 ;
75541
75542   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
75543   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
75544   jresult = (void *)result;
75545   return jresult;
75546 }
75547
75548
75549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
75550   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
75551   Dali::Toolkit::ClampState arg2 ;
75552
75553   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
75554   arg2 = (Dali::Toolkit::ClampState)jarg2;
75555   if (arg1) (arg1)->rotation = arg2;
75556 }
75557
75558
75559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
75560   int jresult ;
75561   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
75562   Dali::Toolkit::ClampState result;
75563
75564   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
75565   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
75566   jresult = (int)result;
75567   return jresult;
75568 }
75569
75570
75571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
75572   void * jresult ;
75573   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
75574
75575   {
75576     try {
75577       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
75578     } catch (std::out_of_range& e) {
75579       {
75580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75581       };
75582     } catch (std::exception& e) {
75583       {
75584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75585       };
75586     } catch (Dali::DaliException e) {
75587       {
75588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75589       };
75590     } catch (...) {
75591       {
75592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75593       };
75594     }
75595   }
75596
75597   jresult = (void *)result;
75598   return jresult;
75599 }
75600
75601
75602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
75603   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
75604
75605   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
75606   {
75607     try {
75608       delete arg1;
75609     } catch (std::out_of_range& e) {
75610       {
75611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75612       };
75613     } catch (std::exception& e) {
75614       {
75615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75616       };
75617     } catch (Dali::DaliException e) {
75618       {
75619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75620       };
75621     } catch (...) {
75622       {
75623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75624       };
75625     }
75626   }
75627
75628 }
75629
75630
75631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
75632   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
75633   Dali::Toolkit::SnapType arg2 ;
75634
75635   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
75636   arg2 = (Dali::Toolkit::SnapType)jarg2;
75637   if (arg1) (arg1)->type = arg2;
75638 }
75639
75640
75641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
75642   int jresult ;
75643   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
75644   Dali::Toolkit::SnapType result;
75645
75646   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
75647   result = (Dali::Toolkit::SnapType) ((arg1)->type);
75648   jresult = (int)result;
75649   return jresult;
75650 }
75651
75652
75653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
75654   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
75655   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
75656
75657   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
75658   arg2 = (Dali::Vector2 *)jarg2;
75659   if (arg1) (arg1)->position = *arg2;
75660 }
75661
75662
75663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
75664   void * jresult ;
75665   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
75666   Dali::Vector2 *result = 0 ;
75667
75668   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
75669   result = (Dali::Vector2 *)& ((arg1)->position);
75670   jresult = (void *)result;
75671   return jresult;
75672 }
75673
75674
75675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
75676   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
75677   float arg2 ;
75678
75679   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
75680   arg2 = (float)jarg2;
75681   if (arg1) (arg1)->duration = arg2;
75682 }
75683
75684
75685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
75686   float jresult ;
75687   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
75688   float result;
75689
75690   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
75691   result = (float) ((arg1)->duration);
75692   jresult = result;
75693   return jresult;
75694 }
75695
75696
75697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
75698   void * jresult ;
75699   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
75700
75701   {
75702     try {
75703       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
75704     } catch (std::out_of_range& e) {
75705       {
75706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75707       };
75708     } catch (std::exception& e) {
75709       {
75710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75711       };
75712     } catch (Dali::DaliException e) {
75713       {
75714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75715       };
75716     } catch (...) {
75717       {
75718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75719       };
75720     }
75721   }
75722
75723   jresult = (void *)result;
75724   return jresult;
75725 }
75726
75727
75728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
75729   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
75730
75731   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
75732   {
75733     try {
75734       delete arg1;
75735     } catch (std::out_of_range& e) {
75736       {
75737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75738       };
75739     } catch (std::exception& e) {
75740       {
75741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75742       };
75743     } catch (Dali::DaliException e) {
75744       {
75745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75746       };
75747     } catch (...) {
75748       {
75749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75750       };
75751     }
75752   }
75753
75754 }
75755
75756
75757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
75758   int jresult ;
75759   int result;
75760
75761   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
75762   jresult = (int)result;
75763   return jresult;
75764 }
75765
75766
75767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
75768   int jresult ;
75769   int result;
75770
75771   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
75772   jresult = (int)result;
75773   return jresult;
75774 }
75775
75776
75777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
75778   int jresult ;
75779   int result;
75780
75781   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
75782   jresult = (int)result;
75783   return jresult;
75784 }
75785
75786
75787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75788   int jresult ;
75789   int result;
75790
75791   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75792   jresult = (int)result;
75793   return jresult;
75794 }
75795
75796
75797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
75798   int jresult ;
75799   int result;
75800
75801   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
75802   jresult = (int)result;
75803   return jresult;
75804 }
75805
75806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
75807   int jresult ;
75808   int result;
75809
75810   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
75811   jresult = (int)result;
75812   return jresult;
75813 }
75814
75815
75816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
75817   int jresult ;
75818   int result;
75819
75820   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
75821   jresult = (int)result;
75822   return jresult;
75823 }
75824
75825
75826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
75827   int jresult ;
75828   int result;
75829
75830   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
75831   jresult = (int)result;
75832   return jresult;
75833 }
75834
75835
75836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
75837   int jresult ;
75838   int result;
75839
75840   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
75841   jresult = (int)result;
75842   return jresult;
75843 }
75844
75845
75846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
75847   int jresult ;
75848   int result;
75849
75850   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
75851   jresult = (int)result;
75852   return jresult;
75853 }
75854
75855
75856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
75857   int jresult ;
75858   int result;
75859
75860   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
75861   jresult = (int)result;
75862   return jresult;
75863 }
75864
75865
75866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
75867   int jresult ;
75868   int result;
75869
75870   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
75871   jresult = (int)result;
75872   return jresult;
75873 }
75874
75875
75876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
75877   int jresult ;
75878   int result;
75879
75880   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
75881   jresult = (int)result;
75882   return jresult;
75883 }
75884
75885
75886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
75887   int jresult ;
75888   int result;
75889
75890   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
75891   jresult = (int)result;
75892   return jresult;
75893 }
75894
75895
75896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
75897   int jresult ;
75898   int result;
75899
75900   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
75901   jresult = (int)result;
75902   return jresult;
75903 }
75904
75905
75906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
75907   int jresult ;
75908   int result;
75909
75910   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
75911   jresult = (int)result;
75912   return jresult;
75913 }
75914
75915
75916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
75917   int jresult ;
75918   int result;
75919
75920   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
75921   jresult = (int)result;
75922   return jresult;
75923 }
75924
75925
75926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
75927   int jresult ;
75928   int result;
75929
75930   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
75931   jresult = (int)result;
75932   return jresult;
75933 }
75934
75935
75936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
75937   int jresult ;
75938   int result;
75939
75940   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
75941   jresult = (int)result;
75942   return jresult;
75943 }
75944
75945
75946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
75947   int jresult ;
75948   int result;
75949
75950   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
75951   jresult = (int)result;
75952   return jresult;
75953 }
75954
75955
75956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
75957   int jresult ;
75958   int result;
75959
75960   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
75961   jresult = (int)result;
75962   return jresult;
75963 }
75964
75965
75966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
75967   int jresult ;
75968   int result;
75969
75970   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
75971   jresult = (int)result;
75972   return jresult;
75973 }
75974
75975
75976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
75977   int jresult ;
75978   int result;
75979
75980   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
75981   jresult = (int)result;
75982   return jresult;
75983 }
75984
75985
75986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
75987   int jresult ;
75988   int result;
75989
75990   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
75991   jresult = (int)result;
75992   return jresult;
75993 }
75994
75995
75996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
75997   int jresult ;
75998   int result;
75999
76000   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
76001   jresult = (int)result;
76002   return jresult;
76003 }
76004
76005
76006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
76007   int jresult ;
76008   int result;
76009
76010   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
76011   jresult = (int)result;
76012   return jresult;
76013 }
76014
76015
76016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
76017   void * jresult ;
76018   Dali::Toolkit::ScrollView::Property *result = 0 ;
76019
76020   {
76021     try {
76022       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
76023     } catch (std::out_of_range& e) {
76024       {
76025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76026       };
76027     } catch (std::exception& e) {
76028       {
76029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76030       };
76031     } catch (Dali::DaliException e) {
76032       {
76033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76034       };
76035     } catch (...) {
76036       {
76037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76038       };
76039     }
76040   }
76041
76042   jresult = (void *)result;
76043   return jresult;
76044 }
76045
76046
76047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
76048   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
76049
76050   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
76051   {
76052     try {
76053       delete arg1;
76054     } catch (std::out_of_range& e) {
76055       {
76056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76057       };
76058     } catch (std::exception& e) {
76059       {
76060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76061       };
76062     } catch (Dali::DaliException e) {
76063       {
76064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76065       };
76066     } catch (...) {
76067       {
76068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76069       };
76070     }
76071   }
76072
76073 }
76074
76075
76076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
76077   void * jresult ;
76078   Dali::Toolkit::ScrollView *result = 0 ;
76079
76080   {
76081     try {
76082       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
76083     } catch (std::out_of_range& e) {
76084       {
76085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76086       };
76087     } catch (std::exception& e) {
76088       {
76089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76090       };
76091     } catch (Dali::DaliException e) {
76092       {
76093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76094       };
76095     } catch (...) {
76096       {
76097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76098       };
76099     }
76100   }
76101
76102   jresult = (void *)result;
76103   return jresult;
76104 }
76105
76106
76107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
76108   void * jresult ;
76109   Dali::Toolkit::ScrollView *arg1 = 0 ;
76110   Dali::Toolkit::ScrollView *result = 0 ;
76111
76112   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76113   if (!arg1) {
76114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
76115     return 0;
76116   }
76117   {
76118     try {
76119       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
76120     } catch (std::out_of_range& e) {
76121       {
76122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76123       };
76124     } catch (std::exception& e) {
76125       {
76126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76127       };
76128     } catch (Dali::DaliException e) {
76129       {
76130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76131       };
76132     } catch (...) {
76133       {
76134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76135       };
76136     }
76137   }
76138
76139   jresult = (void *)result;
76140   return jresult;
76141 }
76142
76143
76144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
76145   void * jresult ;
76146   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76147   Dali::Toolkit::ScrollView *arg2 = 0 ;
76148   Dali::Toolkit::ScrollView *result = 0 ;
76149
76150   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76151   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
76152   if (!arg2) {
76153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
76154     return 0;
76155   }
76156   {
76157     try {
76158       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
76159     } catch (std::out_of_range& e) {
76160       {
76161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76162       };
76163     } catch (std::exception& e) {
76164       {
76165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76166       };
76167     } catch (Dali::DaliException e) {
76168       {
76169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76170       };
76171     } catch (...) {
76172       {
76173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76174       };
76175     }
76176   }
76177
76178   jresult = (void *)result;
76179   return jresult;
76180 }
76181
76182
76183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
76184   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76185
76186   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76187   {
76188     try {
76189       delete arg1;
76190     } catch (std::out_of_range& e) {
76191       {
76192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76193       };
76194     } catch (std::exception& e) {
76195       {
76196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76197       };
76198     } catch (Dali::DaliException e) {
76199       {
76200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76201       };
76202     } catch (...) {
76203       {
76204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76205       };
76206     }
76207   }
76208
76209 }
76210
76211
76212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
76213   void * jresult ;
76214   Dali::Toolkit::ScrollView result;
76215
76216   {
76217     try {
76218       result = Dali::Toolkit::ScrollView::New();
76219     } catch (std::out_of_range& e) {
76220       {
76221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76222       };
76223     } catch (std::exception& e) {
76224       {
76225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76226       };
76227     } catch (Dali::DaliException e) {
76228       {
76229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76230       };
76231     } catch (...) {
76232       {
76233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76234       };
76235     }
76236   }
76237
76238   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
76239   return jresult;
76240 }
76241
76242
76243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
76244   void * jresult ;
76245   Dali::BaseHandle arg1 ;
76246   Dali::BaseHandle *argp1 ;
76247   Dali::Toolkit::ScrollView result;
76248
76249   argp1 = (Dali::BaseHandle *)jarg1;
76250   if (!argp1) {
76251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76252     return 0;
76253   }
76254   arg1 = *argp1;
76255   {
76256     try {
76257       result = Dali::Toolkit::ScrollView::DownCast(arg1);
76258     } catch (std::out_of_range& e) {
76259       {
76260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76261       };
76262     } catch (std::exception& e) {
76263       {
76264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76265       };
76266     } catch (Dali::DaliException e) {
76267       {
76268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76269       };
76270     } catch (...) {
76271       {
76272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76273       };
76274     }
76275   }
76276
76277   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
76278   return jresult;
76279 }
76280
76281
76282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
76283   void * jresult ;
76284   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76285   Dali::AlphaFunction result;
76286
76287   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76288   {
76289     try {
76290       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
76291     } catch (std::out_of_range& e) {
76292       {
76293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76294       };
76295     } catch (std::exception& e) {
76296       {
76297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76298       };
76299     } catch (Dali::DaliException e) {
76300       {
76301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76302       };
76303     } catch (...) {
76304       {
76305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76306       };
76307     }
76308   }
76309
76310   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
76311   return jresult;
76312 }
76313
76314
76315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
76316   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76317   Dali::AlphaFunction arg2 ;
76318   Dali::AlphaFunction *argp2 ;
76319
76320   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76321   argp2 = (Dali::AlphaFunction *)jarg2;
76322   if (!argp2) {
76323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76324     return ;
76325   }
76326   arg2 = *argp2;
76327   {
76328     try {
76329       (arg1)->SetScrollSnapAlphaFunction(arg2);
76330     } catch (std::out_of_range& e) {
76331       {
76332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76333       };
76334     } catch (std::exception& e) {
76335       {
76336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76337       };
76338     } catch (Dali::DaliException e) {
76339       {
76340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76341       };
76342     } catch (...) {
76343       {
76344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76345       };
76346     }
76347   }
76348
76349 }
76350
76351
76352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
76353   void * jresult ;
76354   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76355   Dali::AlphaFunction result;
76356
76357   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76358   {
76359     try {
76360       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
76361     } catch (std::out_of_range& e) {
76362       {
76363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76364       };
76365     } catch (std::exception& e) {
76366       {
76367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76368       };
76369     } catch (Dali::DaliException e) {
76370       {
76371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76372       };
76373     } catch (...) {
76374       {
76375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76376       };
76377     }
76378   }
76379
76380   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
76381   return jresult;
76382 }
76383
76384
76385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
76386   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76387   Dali::AlphaFunction arg2 ;
76388   Dali::AlphaFunction *argp2 ;
76389
76390   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76391   argp2 = (Dali::AlphaFunction *)jarg2;
76392   if (!argp2) {
76393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76394     return ;
76395   }
76396   arg2 = *argp2;
76397   {
76398     try {
76399       (arg1)->SetScrollFlickAlphaFunction(arg2);
76400     } catch (std::out_of_range& e) {
76401       {
76402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76403       };
76404     } catch (std::exception& e) {
76405       {
76406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76407       };
76408     } catch (Dali::DaliException e) {
76409       {
76410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76411       };
76412     } catch (...) {
76413       {
76414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76415       };
76416     }
76417   }
76418
76419 }
76420
76421
76422 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
76423   float jresult ;
76424   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76425   float result;
76426
76427   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76428   {
76429     try {
76430       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
76431     } catch (std::out_of_range& e) {
76432       {
76433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76434       };
76435     } catch (std::exception& e) {
76436       {
76437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76438       };
76439     } catch (Dali::DaliException e) {
76440       {
76441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76442       };
76443     } catch (...) {
76444       {
76445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76446       };
76447     }
76448   }
76449
76450   jresult = result;
76451   return jresult;
76452 }
76453
76454
76455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
76456   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76457   float arg2 ;
76458
76459   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76460   arg2 = (float)jarg2;
76461   {
76462     try {
76463       (arg1)->SetScrollSnapDuration(arg2);
76464     } catch (std::out_of_range& e) {
76465       {
76466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76467       };
76468     } catch (std::exception& e) {
76469       {
76470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76471       };
76472     } catch (Dali::DaliException e) {
76473       {
76474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76475       };
76476     } catch (...) {
76477       {
76478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76479       };
76480     }
76481   }
76482
76483 }
76484
76485
76486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
76487   float jresult ;
76488   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76489   float result;
76490
76491   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76492   {
76493     try {
76494       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
76495     } catch (std::out_of_range& e) {
76496       {
76497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76498       };
76499     } catch (std::exception& e) {
76500       {
76501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76502       };
76503     } catch (Dali::DaliException e) {
76504       {
76505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76506       };
76507     } catch (...) {
76508       {
76509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76510       };
76511     }
76512   }
76513
76514   jresult = result;
76515   return jresult;
76516 }
76517
76518
76519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
76520   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76521   float arg2 ;
76522
76523   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76524   arg2 = (float)jarg2;
76525   {
76526     try {
76527       (arg1)->SetScrollFlickDuration(arg2);
76528     } catch (std::out_of_range& e) {
76529       {
76530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76531       };
76532     } catch (std::exception& e) {
76533       {
76534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76535       };
76536     } catch (Dali::DaliException e) {
76537       {
76538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76539       };
76540     } catch (...) {
76541       {
76542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76543       };
76544     }
76545   }
76546
76547 }
76548
76549
76550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
76551   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76552   Dali::Toolkit::RulerPtr arg2 ;
76553   Dali::Toolkit::RulerPtr *argp2 ;
76554
76555   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76556   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
76557   if (!argp2) {
76558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
76559     return ;
76560   }
76561   arg2 = *argp2;
76562   {
76563     try {
76564       (arg1)->SetRulerX(arg2);
76565     } catch (std::out_of_range& e) {
76566       {
76567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76568       };
76569     } catch (std::exception& e) {
76570       {
76571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76572       };
76573     } catch (Dali::DaliException e) {
76574       {
76575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76576       };
76577     } catch (...) {
76578       {
76579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76580       };
76581     }
76582   }
76583
76584 }
76585
76586
76587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
76588   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76589   Dali::Toolkit::RulerPtr arg2 ;
76590   Dali::Toolkit::RulerPtr *argp2 ;
76591
76592   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76593   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
76594   if (!argp2) {
76595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
76596     return ;
76597   }
76598   arg2 = *argp2;
76599   {
76600     try {
76601       (arg1)->SetRulerY(arg2);
76602     } catch (std::out_of_range& e) {
76603       {
76604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76605       };
76606     } catch (std::exception& e) {
76607       {
76608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76609       };
76610     } catch (Dali::DaliException e) {
76611       {
76612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76613       };
76614     } catch (...) {
76615       {
76616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76617       };
76618     }
76619   }
76620
76621 }
76622
76623
76624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
76625   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76626   bool arg2 ;
76627
76628   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76629   arg2 = jarg2 ? true : false;
76630   {
76631     try {
76632       (arg1)->SetScrollSensitive(arg2);
76633     } catch (std::out_of_range& e) {
76634       {
76635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76636       };
76637     } catch (std::exception& e) {
76638       {
76639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76640       };
76641     } catch (Dali::DaliException e) {
76642       {
76643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76644       };
76645     } catch (...) {
76646       {
76647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76648       };
76649     }
76650   }
76651
76652 }
76653
76654
76655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
76656   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76657   float arg2 ;
76658   float arg3 ;
76659
76660   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76661   arg2 = (float)jarg2;
76662   arg3 = (float)jarg3;
76663   {
76664     try {
76665       (arg1)->SetMaxOvershoot(arg2,arg3);
76666     } catch (std::out_of_range& e) {
76667       {
76668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76669       };
76670     } catch (std::exception& e) {
76671       {
76672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76673       };
76674     } catch (Dali::DaliException e) {
76675       {
76676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76677       };
76678     } catch (...) {
76679       {
76680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76681       };
76682     }
76683   }
76684
76685 }
76686
76687
76688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
76689   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76690   Dali::AlphaFunction arg2 ;
76691   Dali::AlphaFunction *argp2 ;
76692
76693   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76694   argp2 = (Dali::AlphaFunction *)jarg2;
76695   if (!argp2) {
76696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76697     return ;
76698   }
76699   arg2 = *argp2;
76700   {
76701     try {
76702       (arg1)->SetSnapOvershootAlphaFunction(arg2);
76703     } catch (std::out_of_range& e) {
76704       {
76705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76706       };
76707     } catch (std::exception& e) {
76708       {
76709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76710       };
76711     } catch (Dali::DaliException e) {
76712       {
76713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76714       };
76715     } catch (...) {
76716       {
76717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76718       };
76719     }
76720   }
76721
76722 }
76723
76724
76725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
76726   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76727   float arg2 ;
76728
76729   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76730   arg2 = (float)jarg2;
76731   {
76732     try {
76733       (arg1)->SetSnapOvershootDuration(arg2);
76734     } catch (std::out_of_range& e) {
76735       {
76736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76737       };
76738     } catch (std::exception& e) {
76739       {
76740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76741       };
76742     } catch (Dali::DaliException e) {
76743       {
76744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76745       };
76746     } catch (...) {
76747       {
76748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76749       };
76750     }
76751   }
76752
76753 }
76754
76755
76756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
76757   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76758   bool arg2 ;
76759
76760   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76761   arg2 = jarg2 ? true : false;
76762   {
76763     try {
76764       (arg1)->SetActorAutoSnap(arg2);
76765     } catch (std::out_of_range& e) {
76766       {
76767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76768       };
76769     } catch (std::exception& e) {
76770       {
76771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76772       };
76773     } catch (Dali::DaliException e) {
76774       {
76775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76776       };
76777     } catch (...) {
76778       {
76779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76780       };
76781     }
76782   }
76783
76784 }
76785
76786
76787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
76788   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76789   bool arg2 ;
76790
76791   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76792   arg2 = jarg2 ? true : false;
76793   {
76794     try {
76795       (arg1)->SetWrapMode(arg2);
76796     } catch (std::out_of_range& e) {
76797       {
76798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76799       };
76800     } catch (std::exception& e) {
76801       {
76802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76803       };
76804     } catch (Dali::DaliException e) {
76805       {
76806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76807       };
76808     } catch (...) {
76809       {
76810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76811       };
76812     }
76813   }
76814
76815 }
76816
76817
76818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
76819   int jresult ;
76820   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76821   int result;
76822
76823   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76824   {
76825     try {
76826       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
76827     } catch (std::out_of_range& e) {
76828       {
76829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76830       };
76831     } catch (std::exception& e) {
76832       {
76833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76834       };
76835     } catch (Dali::DaliException e) {
76836       {
76837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76838       };
76839     } catch (...) {
76840       {
76841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76842       };
76843     }
76844   }
76845
76846   jresult = result;
76847   return jresult;
76848 }
76849
76850
76851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
76852   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76853   int arg2 ;
76854
76855   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76856   arg2 = (int)jarg2;
76857   {
76858     try {
76859       (arg1)->SetScrollUpdateDistance(arg2);
76860     } catch (std::out_of_range& e) {
76861       {
76862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76863       };
76864     } catch (std::exception& e) {
76865       {
76866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76867       };
76868     } catch (Dali::DaliException e) {
76869       {
76870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76871       };
76872     } catch (...) {
76873       {
76874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76875       };
76876     }
76877   }
76878
76879 }
76880
76881
76882 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
76883   unsigned int jresult ;
76884   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76885   bool result;
76886
76887   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76888   {
76889     try {
76890       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
76891     } catch (std::out_of_range& e) {
76892       {
76893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76894       };
76895     } catch (std::exception& e) {
76896       {
76897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76898       };
76899     } catch (Dali::DaliException e) {
76900       {
76901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76902       };
76903     } catch (...) {
76904       {
76905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76906       };
76907     }
76908   }
76909
76910   jresult = result;
76911   return jresult;
76912 }
76913
76914
76915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
76916   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76917   bool arg2 ;
76918
76919   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76920   arg2 = jarg2 ? true : false;
76921   {
76922     try {
76923       (arg1)->SetAxisAutoLock(arg2);
76924     } catch (std::out_of_range& e) {
76925       {
76926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76927       };
76928     } catch (std::exception& e) {
76929       {
76930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76931       };
76932     } catch (Dali::DaliException e) {
76933       {
76934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76935       };
76936     } catch (...) {
76937       {
76938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76939       };
76940     }
76941   }
76942
76943 }
76944
76945
76946 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
76947   float jresult ;
76948   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76949   float result;
76950
76951   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76952   {
76953     try {
76954       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
76955     } catch (std::out_of_range& e) {
76956       {
76957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76958       };
76959     } catch (std::exception& e) {
76960       {
76961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76962       };
76963     } catch (Dali::DaliException e) {
76964       {
76965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76966       };
76967     } catch (...) {
76968       {
76969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76970       };
76971     }
76972   }
76973
76974   jresult = result;
76975   return jresult;
76976 }
76977
76978
76979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
76980   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76981   float arg2 ;
76982
76983   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76984   arg2 = (float)jarg2;
76985   {
76986     try {
76987       (arg1)->SetAxisAutoLockGradient(arg2);
76988     } catch (std::out_of_range& e) {
76989       {
76990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76991       };
76992     } catch (std::exception& e) {
76993       {
76994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76995       };
76996     } catch (Dali::DaliException e) {
76997       {
76998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76999       };
77000     } catch (...) {
77001       {
77002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77003       };
77004     }
77005   }
77006
77007 }
77008
77009
77010 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
77011   float jresult ;
77012   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77013   float result;
77014
77015   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77016   {
77017     try {
77018       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
77019     } catch (std::out_of_range& e) {
77020       {
77021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77022       };
77023     } catch (std::exception& e) {
77024       {
77025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77026       };
77027     } catch (Dali::DaliException e) {
77028       {
77029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77030       };
77031     } catch (...) {
77032       {
77033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77034       };
77035     }
77036   }
77037
77038   jresult = result;
77039   return jresult;
77040 }
77041
77042
77043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
77044   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77045   float arg2 ;
77046
77047   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77048   arg2 = (float)jarg2;
77049   {
77050     try {
77051       (arg1)->SetFrictionCoefficient(arg2);
77052     } catch (std::out_of_range& e) {
77053       {
77054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77055       };
77056     } catch (std::exception& e) {
77057       {
77058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77059       };
77060     } catch (Dali::DaliException e) {
77061       {
77062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77063       };
77064     } catch (...) {
77065       {
77066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77067       };
77068     }
77069   }
77070
77071 }
77072
77073
77074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
77075   float jresult ;
77076   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77077   float result;
77078
77079   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77080   {
77081     try {
77082       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
77083     } catch (std::out_of_range& e) {
77084       {
77085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77086       };
77087     } catch (std::exception& e) {
77088       {
77089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77090       };
77091     } catch (Dali::DaliException e) {
77092       {
77093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77094       };
77095     } catch (...) {
77096       {
77097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77098       };
77099     }
77100   }
77101
77102   jresult = result;
77103   return jresult;
77104 }
77105
77106
77107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
77108   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77109   float arg2 ;
77110
77111   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77112   arg2 = (float)jarg2;
77113   {
77114     try {
77115       (arg1)->SetFlickSpeedCoefficient(arg2);
77116     } catch (std::out_of_range& e) {
77117       {
77118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77119       };
77120     } catch (std::exception& e) {
77121       {
77122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77123       };
77124     } catch (Dali::DaliException e) {
77125       {
77126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77127       };
77128     } catch (...) {
77129       {
77130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77131       };
77132     }
77133   }
77134
77135 }
77136
77137
77138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
77139   void * jresult ;
77140   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77141   Dali::Vector2 result;
77142
77143   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77144   {
77145     try {
77146       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
77147     } catch (std::out_of_range& e) {
77148       {
77149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77150       };
77151     } catch (std::exception& e) {
77152       {
77153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77154       };
77155     } catch (Dali::DaliException e) {
77156       {
77157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77158       };
77159     } catch (...) {
77160       {
77161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77162       };
77163     }
77164   }
77165
77166   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
77167   return jresult;
77168 }
77169
77170
77171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
77172   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77173   Dali::Vector2 *arg2 = 0 ;
77174
77175   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77176   arg2 = (Dali::Vector2 *)jarg2;
77177   if (!arg2) {
77178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
77179     return ;
77180   }
77181   {
77182     try {
77183       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 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 float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
77207   float jresult ;
77208   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77209   float result;
77210
77211   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77212   {
77213     try {
77214       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
77215     } catch (std::out_of_range& e) {
77216       {
77217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77218       };
77219     } catch (std::exception& e) {
77220       {
77221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77222       };
77223     } catch (Dali::DaliException e) {
77224       {
77225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77226       };
77227     } catch (...) {
77228       {
77229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77230       };
77231     }
77232   }
77233
77234   jresult = result;
77235   return jresult;
77236 }
77237
77238
77239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
77240   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77241   float arg2 ;
77242
77243   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77244   arg2 = (float)jarg2;
77245   {
77246     try {
77247       (arg1)->SetMinimumSpeedForFlick(arg2);
77248     } catch (std::out_of_range& e) {
77249       {
77250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77251       };
77252     } catch (std::exception& e) {
77253       {
77254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77255       };
77256     } catch (Dali::DaliException e) {
77257       {
77258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77259       };
77260     } catch (...) {
77261       {
77262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77263       };
77264     }
77265   }
77266
77267 }
77268
77269
77270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
77271   float jresult ;
77272   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77273   float result;
77274
77275   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77276   {
77277     try {
77278       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
77279     } catch (std::out_of_range& e) {
77280       {
77281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77282       };
77283     } catch (std::exception& e) {
77284       {
77285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77286       };
77287     } catch (Dali::DaliException e) {
77288       {
77289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77290       };
77291     } catch (...) {
77292       {
77293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77294       };
77295     }
77296   }
77297
77298   jresult = result;
77299   return jresult;
77300 }
77301
77302
77303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
77304   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77305   float arg2 ;
77306
77307   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77308   arg2 = (float)jarg2;
77309   {
77310     try {
77311       (arg1)->SetMaxFlickSpeed(arg2);
77312     } catch (std::out_of_range& e) {
77313       {
77314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77315       };
77316     } catch (std::exception& e) {
77317       {
77318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77319       };
77320     } catch (Dali::DaliException e) {
77321       {
77322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77323       };
77324     } catch (...) {
77325       {
77326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77327       };
77328     }
77329   }
77330
77331 }
77332
77333
77334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
77335   void * jresult ;
77336   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77337   Dali::Vector2 result;
77338
77339   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77340   {
77341     try {
77342       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
77343     } catch (std::out_of_range& e) {
77344       {
77345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77346       };
77347     } catch (std::exception& e) {
77348       {
77349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77350       };
77351     } catch (Dali::DaliException e) {
77352       {
77353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77354       };
77355     } catch (...) {
77356       {
77357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77358       };
77359     }
77360   }
77361
77362   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
77363   return jresult;
77364 }
77365
77366
77367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
77368   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77369   Dali::Vector2 arg2 ;
77370   Dali::Vector2 *argp2 ;
77371
77372   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77373   argp2 = (Dali::Vector2 *)jarg2;
77374   if (!argp2) {
77375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
77376     return ;
77377   }
77378   arg2 = *argp2;
77379   {
77380     try {
77381       (arg1)->SetWheelScrollDistanceStep(arg2);
77382     } catch (std::out_of_range& e) {
77383       {
77384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77385       };
77386     } catch (std::exception& e) {
77387       {
77388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77389       };
77390     } catch (Dali::DaliException e) {
77391       {
77392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77393       };
77394     } catch (...) {
77395       {
77396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77397       };
77398     }
77399   }
77400
77401 }
77402
77403
77404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
77405   void * jresult ;
77406   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77407   Dali::Vector2 result;
77408
77409   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77410   {
77411     try {
77412       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
77413     } catch (std::out_of_range& e) {
77414       {
77415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77416       };
77417     } catch (std::exception& e) {
77418       {
77419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77420       };
77421     } catch (Dali::DaliException e) {
77422       {
77423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77424       };
77425     } catch (...) {
77426       {
77427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77428       };
77429     }
77430   }
77431
77432   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
77433   return jresult;
77434 }
77435
77436
77437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
77438   unsigned int jresult ;
77439   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77440   unsigned int result;
77441
77442   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77443   {
77444     try {
77445       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
77446     } catch (std::out_of_range& e) {
77447       {
77448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77449       };
77450     } catch (std::exception& e) {
77451       {
77452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77453       };
77454     } catch (Dali::DaliException e) {
77455       {
77456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77457       };
77458     } catch (...) {
77459       {
77460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77461       };
77462     }
77463   }
77464
77465   jresult = result;
77466   return jresult;
77467 }
77468
77469
77470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
77471   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77472   Dali::Vector2 *arg2 = 0 ;
77473
77474   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77475   arg2 = (Dali::Vector2 *)jarg2;
77476   if (!arg2) {
77477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
77478     return ;
77479   }
77480   {
77481     try {
77482       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
77483     } catch (std::out_of_range& e) {
77484       {
77485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77486       };
77487     } catch (std::exception& e) {
77488       {
77489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77490       };
77491     } catch (Dali::DaliException e) {
77492       {
77493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77494       };
77495     } catch (...) {
77496       {
77497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77498       };
77499     }
77500   }
77501
77502 }
77503
77504
77505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
77506   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77507   Dali::Vector2 *arg2 = 0 ;
77508   float arg3 ;
77509
77510   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77511   arg2 = (Dali::Vector2 *)jarg2;
77512   if (!arg2) {
77513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
77514     return ;
77515   }
77516   arg3 = (float)jarg3;
77517   {
77518     try {
77519       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
77520     } catch (std::out_of_range& e) {
77521       {
77522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77523       };
77524     } catch (std::exception& e) {
77525       {
77526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77527       };
77528     } catch (Dali::DaliException e) {
77529       {
77530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77531       };
77532     } catch (...) {
77533       {
77534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77535       };
77536     }
77537   }
77538
77539 }
77540
77541
77542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
77543   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77544   Dali::Vector2 *arg2 = 0 ;
77545   float arg3 ;
77546   Dali::AlphaFunction arg4 ;
77547   Dali::AlphaFunction *argp4 ;
77548
77549   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77550   arg2 = (Dali::Vector2 *)jarg2;
77551   if (!arg2) {
77552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
77553     return ;
77554   }
77555   arg3 = (float)jarg3;
77556   argp4 = (Dali::AlphaFunction *)jarg4;
77557   if (!argp4) {
77558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
77559     return ;
77560   }
77561   arg4 = *argp4;
77562   {
77563     try {
77564       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
77565     } catch (std::out_of_range& e) {
77566       {
77567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77568       };
77569     } catch (std::exception& e) {
77570       {
77571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77572       };
77573     } catch (Dali::DaliException e) {
77574       {
77575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77576       };
77577     } catch (...) {
77578       {
77579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77580       };
77581     }
77582   }
77583
77584 }
77585
77586
77587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
77588   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77589   Dali::Vector2 *arg2 = 0 ;
77590   float arg3 ;
77591   Dali::Toolkit::DirectionBias arg4 ;
77592   Dali::Toolkit::DirectionBias arg5 ;
77593
77594   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77595   arg2 = (Dali::Vector2 *)jarg2;
77596   if (!arg2) {
77597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
77598     return ;
77599   }
77600   arg3 = (float)jarg3;
77601   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
77602   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
77603   {
77604     try {
77605       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
77606     } catch (std::out_of_range& e) {
77607       {
77608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77609       };
77610     } catch (std::exception& e) {
77611       {
77612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77613       };
77614     } catch (Dali::DaliException e) {
77615       {
77616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77617       };
77618     } catch (...) {
77619       {
77620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77621       };
77622     }
77623   }
77624
77625 }
77626
77627
77628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
77629   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77630   Dali::Vector2 *arg2 = 0 ;
77631   float arg3 ;
77632   Dali::AlphaFunction arg4 ;
77633   Dali::Toolkit::DirectionBias arg5 ;
77634   Dali::Toolkit::DirectionBias arg6 ;
77635   Dali::AlphaFunction *argp4 ;
77636
77637   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77638   arg2 = (Dali::Vector2 *)jarg2;
77639   if (!arg2) {
77640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
77641     return ;
77642   }
77643   arg3 = (float)jarg3;
77644   argp4 = (Dali::AlphaFunction *)jarg4;
77645   if (!argp4) {
77646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
77647     return ;
77648   }
77649   arg4 = *argp4;
77650   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
77651   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
77652   {
77653     try {
77654       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
77655     } catch (std::out_of_range& e) {
77656       {
77657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77658       };
77659     } catch (std::exception& e) {
77660       {
77661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77662       };
77663     } catch (Dali::DaliException e) {
77664       {
77665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77666       };
77667     } catch (...) {
77668       {
77669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77670       };
77671     }
77672   }
77673
77674 }
77675
77676
77677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
77678   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77679   unsigned int arg2 ;
77680
77681   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77682   arg2 = (unsigned int)jarg2;
77683   {
77684     try {
77685       (arg1)->ScrollTo(arg2);
77686     } catch (std::out_of_range& e) {
77687       {
77688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77689       };
77690     } catch (std::exception& e) {
77691       {
77692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77693       };
77694     } catch (Dali::DaliException e) {
77695       {
77696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77697       };
77698     } catch (...) {
77699       {
77700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77701       };
77702     }
77703   }
77704
77705 }
77706
77707
77708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
77709   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77710   unsigned int arg2 ;
77711   float arg3 ;
77712
77713   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77714   arg2 = (unsigned int)jarg2;
77715   arg3 = (float)jarg3;
77716   {
77717     try {
77718       (arg1)->ScrollTo(arg2,arg3);
77719     } catch (std::out_of_range& e) {
77720       {
77721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77722       };
77723     } catch (std::exception& e) {
77724       {
77725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77726       };
77727     } catch (Dali::DaliException e) {
77728       {
77729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77730       };
77731     } catch (...) {
77732       {
77733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77734       };
77735     }
77736   }
77737
77738 }
77739
77740
77741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
77742   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77743   unsigned int arg2 ;
77744   float arg3 ;
77745   Dali::Toolkit::DirectionBias arg4 ;
77746
77747   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77748   arg2 = (unsigned int)jarg2;
77749   arg3 = (float)jarg3;
77750   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
77751   {
77752     try {
77753       (arg1)->ScrollTo(arg2,arg3,arg4);
77754     } catch (std::out_of_range& e) {
77755       {
77756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77757       };
77758     } catch (std::exception& e) {
77759       {
77760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77761       };
77762     } catch (Dali::DaliException e) {
77763       {
77764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77765       };
77766     } catch (...) {
77767       {
77768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77769       };
77770     }
77771   }
77772
77773 }
77774
77775
77776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
77777   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77778   Dali::Actor *arg2 = 0 ;
77779
77780   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77781   arg2 = (Dali::Actor *)jarg2;
77782   if (!arg2) {
77783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
77784     return ;
77785   }
77786   {
77787     try {
77788       (arg1)->ScrollTo(*arg2);
77789     } catch (std::out_of_range& e) {
77790       {
77791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77792       };
77793     } catch (std::exception& e) {
77794       {
77795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77796       };
77797     } catch (Dali::DaliException e) {
77798       {
77799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77800       };
77801     } catch (...) {
77802       {
77803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77804       };
77805     }
77806   }
77807
77808 }
77809
77810
77811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
77812   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77813   Dali::Actor *arg2 = 0 ;
77814   float arg3 ;
77815
77816   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77817   arg2 = (Dali::Actor *)jarg2;
77818   if (!arg2) {
77819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
77820     return ;
77821   }
77822   arg3 = (float)jarg3;
77823   {
77824     try {
77825       (arg1)->ScrollTo(*arg2,arg3);
77826     } catch (std::out_of_range& e) {
77827       {
77828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77829       };
77830     } catch (std::exception& e) {
77831       {
77832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77833       };
77834     } catch (Dali::DaliException e) {
77835       {
77836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77837       };
77838     } catch (...) {
77839       {
77840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77841       };
77842     }
77843   }
77844
77845 }
77846
77847
77848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
77849   unsigned int jresult ;
77850   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77851   bool result;
77852
77853   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77854   {
77855     try {
77856       result = (bool)(arg1)->ScrollToSnapPoint();
77857     } catch (std::out_of_range& e) {
77858       {
77859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77860       };
77861     } catch (std::exception& e) {
77862       {
77863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77864       };
77865     } catch (Dali::DaliException e) {
77866       {
77867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77868       };
77869     } catch (...) {
77870       {
77871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77872       };
77873     }
77874   }
77875
77876   jresult = result;
77877   return jresult;
77878 }
77879
77880
77881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
77882   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77883   Dali::Constraint arg2 ;
77884   Dali::Constraint *argp2 ;
77885
77886   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77887   argp2 = (Dali::Constraint *)jarg2;
77888   if (!argp2) {
77889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
77890     return ;
77891   }
77892   arg2 = *argp2;
77893   {
77894     try {
77895       (arg1)->ApplyConstraintToChildren(arg2);
77896     } catch (std::out_of_range& e) {
77897       {
77898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77899       };
77900     } catch (std::exception& e) {
77901       {
77902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77903       };
77904     } catch (Dali::DaliException e) {
77905       {
77906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77907       };
77908     } catch (...) {
77909       {
77910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77911       };
77912     }
77913   }
77914
77915 }
77916
77917
77918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
77919   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77920
77921   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77922   {
77923     try {
77924       (arg1)->RemoveConstraintsFromChildren();
77925     } catch (std::out_of_range& e) {
77926       {
77927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77928       };
77929     } catch (std::exception& e) {
77930       {
77931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77932       };
77933     } catch (Dali::DaliException e) {
77934       {
77935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77936       };
77937     } catch (...) {
77938       {
77939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77940       };
77941     }
77942   }
77943
77944 }
77945
77946
77947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
77948   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77949   Dali::Toolkit::ScrollViewEffect arg2 ;
77950   Dali::Toolkit::ScrollViewEffect *argp2 ;
77951
77952   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77953   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
77954   if (!argp2) {
77955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
77956     return ;
77957   }
77958   arg2 = *argp2;
77959   {
77960     try {
77961       (arg1)->ApplyEffect(arg2);
77962     } catch (std::out_of_range& e) {
77963       {
77964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77965       };
77966     } catch (std::exception& e) {
77967       {
77968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77969       };
77970     } catch (Dali::DaliException e) {
77971       {
77972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77973       };
77974     } catch (...) {
77975       {
77976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77977       };
77978     }
77979   }
77980
77981 }
77982
77983
77984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
77985   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77986   Dali::Toolkit::ScrollViewEffect arg2 ;
77987   Dali::Toolkit::ScrollViewEffect *argp2 ;
77988
77989   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77990   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
77991   if (!argp2) {
77992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
77993     return ;
77994   }
77995   arg2 = *argp2;
77996   {
77997     try {
77998       (arg1)->RemoveEffect(arg2);
77999     } catch (std::out_of_range& e) {
78000       {
78001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78002       };
78003     } catch (std::exception& e) {
78004       {
78005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78006       };
78007     } catch (Dali::DaliException e) {
78008       {
78009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78010       };
78011     } catch (...) {
78012       {
78013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78014       };
78015     }
78016   }
78017
78018 }
78019
78020
78021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
78022   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78023
78024   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78025   {
78026     try {
78027       (arg1)->RemoveAllEffects();
78028     } catch (std::out_of_range& e) {
78029       {
78030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78031       };
78032     } catch (std::exception& e) {
78033       {
78034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78035       };
78036     } catch (Dali::DaliException e) {
78037       {
78038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78039       };
78040     } catch (...) {
78041       {
78042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78043       };
78044     }
78045   }
78046
78047 }
78048
78049
78050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
78051   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78052   Dali::Actor arg2 ;
78053   Dali::Actor *argp2 ;
78054
78055   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78056   argp2 = (Dali::Actor *)jarg2;
78057   if (!argp2) {
78058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78059     return ;
78060   }
78061   arg2 = *argp2;
78062   {
78063     try {
78064       (arg1)->BindActor(arg2);
78065     } catch (std::out_of_range& e) {
78066       {
78067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78068       };
78069     } catch (std::exception& e) {
78070       {
78071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78072       };
78073     } catch (Dali::DaliException e) {
78074       {
78075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78076       };
78077     } catch (...) {
78078       {
78079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78080       };
78081     }
78082   }
78083
78084 }
78085
78086
78087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
78088   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78089   Dali::Actor arg2 ;
78090   Dali::Actor *argp2 ;
78091
78092   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78093   argp2 = (Dali::Actor *)jarg2;
78094   if (!argp2) {
78095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78096     return ;
78097   }
78098   arg2 = *argp2;
78099   {
78100     try {
78101       (arg1)->UnbindActor(arg2);
78102     } catch (std::out_of_range& e) {
78103       {
78104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78105       };
78106     } catch (std::exception& e) {
78107       {
78108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78109       };
78110     } catch (Dali::DaliException e) {
78111       {
78112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78113       };
78114     } catch (...) {
78115       {
78116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78117       };
78118     }
78119   }
78120
78121 }
78122
78123
78124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
78125   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78126   Dali::Radian arg2 ;
78127   Dali::Radian arg3 ;
78128   Dali::Radian *argp2 ;
78129   Dali::Radian *argp3 ;
78130
78131   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78132   argp2 = (Dali::Radian *)jarg2;
78133   if (!argp2) {
78134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
78135     return ;
78136   }
78137   arg2 = *argp2;
78138   argp3 = (Dali::Radian *)jarg3;
78139   if (!argp3) {
78140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
78141     return ;
78142   }
78143   arg3 = *argp3;
78144   {
78145     try {
78146       (arg1)->SetScrollingDirection(arg2,arg3);
78147     } catch (std::out_of_range& e) {
78148       {
78149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78150       };
78151     } catch (std::exception& e) {
78152       {
78153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78154       };
78155     } catch (Dali::DaliException e) {
78156       {
78157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78158       };
78159     } catch (...) {
78160       {
78161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78162       };
78163     }
78164   }
78165
78166 }
78167
78168
78169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
78170   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78171   Dali::Radian arg2 ;
78172   Dali::Radian *argp2 ;
78173
78174   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78175   argp2 = (Dali::Radian *)jarg2;
78176   if (!argp2) {
78177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
78178     return ;
78179   }
78180   arg2 = *argp2;
78181   {
78182     try {
78183       (arg1)->SetScrollingDirection(arg2);
78184     } catch (std::out_of_range& e) {
78185       {
78186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78187       };
78188     } catch (std::exception& e) {
78189       {
78190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78191       };
78192     } catch (Dali::DaliException e) {
78193       {
78194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78195       };
78196     } catch (...) {
78197       {
78198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78199       };
78200     }
78201   }
78202
78203 }
78204
78205
78206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
78207   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78208   Dali::Radian arg2 ;
78209   Dali::Radian *argp2 ;
78210
78211   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78212   argp2 = (Dali::Radian *)jarg2;
78213   if (!argp2) {
78214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
78215     return ;
78216   }
78217   arg2 = *argp2;
78218   {
78219     try {
78220       (arg1)->RemoveScrollingDirection(arg2);
78221     } catch (std::out_of_range& e) {
78222       {
78223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78224       };
78225     } catch (std::exception& e) {
78226       {
78227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78228       };
78229     } catch (Dali::DaliException e) {
78230       {
78231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78232       };
78233     } catch (...) {
78234       {
78235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78236       };
78237     }
78238   }
78239
78240 }
78241
78242
78243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
78244   void * jresult ;
78245   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78246   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
78247
78248   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78249   {
78250     try {
78251       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
78252     } catch (std::out_of_range& e) {
78253       {
78254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78255       };
78256     } catch (std::exception& e) {
78257       {
78258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78259       };
78260     } catch (Dali::DaliException e) {
78261       {
78262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78263       };
78264     } catch (...) {
78265       {
78266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78267       };
78268     }
78269   }
78270
78271   jresult = (void *)result;
78272   return jresult;
78273 }
78274
78275
78276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
78277   int jresult ;
78278   int result;
78279
78280   result = (int)Dali::Toolkit::TableView::Property::ROWS;
78281   jresult = (int)result;
78282   return jresult;
78283 }
78284
78285
78286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
78287   int jresult ;
78288   int result;
78289
78290   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
78291   jresult = (int)result;
78292   return jresult;
78293 }
78294
78295
78296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
78297   int jresult ;
78298   int result;
78299
78300   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
78301   jresult = (int)result;
78302   return jresult;
78303 }
78304
78305
78306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
78307   int jresult ;
78308   int result;
78309
78310   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
78311   jresult = (int)result;
78312   return jresult;
78313 }
78314
78315
78316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
78317   int jresult ;
78318   int result;
78319
78320   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
78321   jresult = (int)result;
78322   return jresult;
78323 }
78324
78325
78326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
78327   void * jresult ;
78328   Dali::Toolkit::TableView::Property *result = 0 ;
78329
78330   {
78331     try {
78332       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
78333     } catch (std::out_of_range& e) {
78334       {
78335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78336       };
78337     } catch (std::exception& e) {
78338       {
78339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78340       };
78341     } catch (Dali::DaliException e) {
78342       {
78343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78344       };
78345     } catch (...) {
78346       {
78347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78348       };
78349     }
78350   }
78351
78352   jresult = (void *)result;
78353   return jresult;
78354 }
78355
78356
78357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
78358   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
78359
78360   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
78361   {
78362     try {
78363       delete arg1;
78364     } catch (std::out_of_range& e) {
78365       {
78366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78367       };
78368     } catch (std::exception& e) {
78369       {
78370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78371       };
78372     } catch (Dali::DaliException e) {
78373       {
78374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78375       };
78376     } catch (...) {
78377       {
78378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78379       };
78380     }
78381   }
78382
78383 }
78384
78385
78386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
78387   int jresult ;
78388   int result;
78389
78390   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
78391   jresult = (int)result;
78392   return jresult;
78393 }
78394
78395
78396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
78397   int jresult ;
78398   int result;
78399
78400   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
78401   jresult = (int)result;
78402   return jresult;
78403 }
78404
78405
78406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
78407   int jresult ;
78408   int result;
78409
78410   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
78411   jresult = (int)result;
78412   return jresult;
78413 }
78414
78415
78416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
78417   int jresult ;
78418   int result;
78419
78420   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
78421   jresult = (int)result;
78422   return jresult;
78423 }
78424
78425
78426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
78427   int jresult ;
78428   int result;
78429
78430   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
78431   jresult = (int)result;
78432   return jresult;
78433 }
78434
78435
78436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
78437   void * jresult ;
78438   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
78439
78440   {
78441     try {
78442       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
78443     } catch (std::out_of_range& e) {
78444       {
78445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78446       };
78447     } catch (std::exception& e) {
78448       {
78449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78450       };
78451     } catch (Dali::DaliException e) {
78452       {
78453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78454       };
78455     } catch (...) {
78456       {
78457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78458       };
78459     }
78460   }
78461
78462   jresult = (void *)result;
78463   return jresult;
78464 }
78465
78466
78467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
78468   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
78469
78470   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
78471   {
78472     try {
78473       delete arg1;
78474     } catch (std::out_of_range& e) {
78475       {
78476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78477       };
78478     } catch (std::exception& e) {
78479       {
78480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78481       };
78482     } catch (Dali::DaliException e) {
78483       {
78484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78485       };
78486     } catch (...) {
78487       {
78488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78489       };
78490     }
78491   }
78492
78493 }
78494
78495
78496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
78497   void * jresult ;
78498   unsigned int arg1 ;
78499   unsigned int arg2 ;
78500   unsigned int arg3 ;
78501   unsigned int arg4 ;
78502   Dali::Toolkit::TableView::CellPosition *result = 0 ;
78503
78504   arg1 = (unsigned int)jarg1;
78505   arg2 = (unsigned int)jarg2;
78506   arg3 = (unsigned int)jarg3;
78507   arg4 = (unsigned int)jarg4;
78508   {
78509     try {
78510       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
78511     } catch (std::out_of_range& e) {
78512       {
78513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78514       };
78515     } catch (std::exception& e) {
78516       {
78517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78518       };
78519     } catch (Dali::DaliException e) {
78520       {
78521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78522       };
78523     } catch (...) {
78524       {
78525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78526       };
78527     }
78528   }
78529
78530   jresult = (void *)result;
78531   return jresult;
78532 }
78533
78534
78535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
78536   void * jresult ;
78537   unsigned int arg1 ;
78538   unsigned int arg2 ;
78539   unsigned int arg3 ;
78540   Dali::Toolkit::TableView::CellPosition *result = 0 ;
78541
78542   arg1 = (unsigned int)jarg1;
78543   arg2 = (unsigned int)jarg2;
78544   arg3 = (unsigned int)jarg3;
78545   {
78546     try {
78547       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
78548     } catch (std::out_of_range& e) {
78549       {
78550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78551       };
78552     } catch (std::exception& e) {
78553       {
78554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78555       };
78556     } catch (Dali::DaliException e) {
78557       {
78558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78559       };
78560     } catch (...) {
78561       {
78562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78563       };
78564     }
78565   }
78566
78567   jresult = (void *)result;
78568   return jresult;
78569 }
78570
78571
78572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
78573   void * jresult ;
78574   unsigned int arg1 ;
78575   unsigned int arg2 ;
78576   Dali::Toolkit::TableView::CellPosition *result = 0 ;
78577
78578   arg1 = (unsigned int)jarg1;
78579   arg2 = (unsigned int)jarg2;
78580   {
78581     try {
78582       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
78583     } catch (std::out_of_range& e) {
78584       {
78585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78586       };
78587     } catch (std::exception& e) {
78588       {
78589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78590       };
78591     } catch (Dali::DaliException e) {
78592       {
78593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78594       };
78595     } catch (...) {
78596       {
78597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78598       };
78599     }
78600   }
78601
78602   jresult = (void *)result;
78603   return jresult;
78604 }
78605
78606
78607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
78608   void * jresult ;
78609   unsigned int arg1 ;
78610   Dali::Toolkit::TableView::CellPosition *result = 0 ;
78611
78612   arg1 = (unsigned int)jarg1;
78613   {
78614     try {
78615       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
78616     } catch (std::out_of_range& e) {
78617       {
78618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78619       };
78620     } catch (std::exception& e) {
78621       {
78622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78623       };
78624     } catch (Dali::DaliException e) {
78625       {
78626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78627       };
78628     } catch (...) {
78629       {
78630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78631       };
78632     }
78633   }
78634
78635   jresult = (void *)result;
78636   return jresult;
78637 }
78638
78639
78640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
78641   void * jresult ;
78642   Dali::Toolkit::TableView::CellPosition *result = 0 ;
78643
78644   {
78645     try {
78646       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
78647     } catch (std::out_of_range& e) {
78648       {
78649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78650       };
78651     } catch (std::exception& e) {
78652       {
78653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78654       };
78655     } catch (Dali::DaliException e) {
78656       {
78657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78658       };
78659     } catch (...) {
78660       {
78661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78662       };
78663     }
78664   }
78665
78666   jresult = (void *)result;
78667   return jresult;
78668 }
78669
78670
78671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
78672   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
78673   unsigned int arg2 ;
78674
78675   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
78676   arg2 = (unsigned int)jarg2;
78677   if (arg1) (arg1)->rowIndex = arg2;
78678 }
78679
78680
78681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
78682   unsigned int jresult ;
78683   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
78684   unsigned int result;
78685
78686   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
78687   result = (unsigned int) ((arg1)->rowIndex);
78688   jresult = result;
78689   return jresult;
78690 }
78691
78692
78693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
78694   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
78695   unsigned int arg2 ;
78696
78697   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
78698   arg2 = (unsigned int)jarg2;
78699   if (arg1) (arg1)->columnIndex = arg2;
78700 }
78701
78702
78703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
78704   unsigned int jresult ;
78705   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
78706   unsigned int result;
78707
78708   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
78709   result = (unsigned int) ((arg1)->columnIndex);
78710   jresult = result;
78711   return jresult;
78712 }
78713
78714
78715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
78716   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
78717   unsigned int arg2 ;
78718
78719   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
78720   arg2 = (unsigned int)jarg2;
78721   if (arg1) (arg1)->rowSpan = arg2;
78722 }
78723
78724
78725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
78726   unsigned int jresult ;
78727   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
78728   unsigned int result;
78729
78730   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
78731   result = (unsigned int) ((arg1)->rowSpan);
78732   jresult = result;
78733   return jresult;
78734 }
78735
78736
78737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
78738   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
78739   unsigned int arg2 ;
78740
78741   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
78742   arg2 = (unsigned int)jarg2;
78743   if (arg1) (arg1)->columnSpan = arg2;
78744 }
78745
78746
78747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
78748   unsigned int jresult ;
78749   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
78750   unsigned int result;
78751
78752   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
78753   result = (unsigned int) ((arg1)->columnSpan);
78754   jresult = result;
78755   return jresult;
78756 }
78757
78758
78759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
78760   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
78761
78762   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
78763   {
78764     try {
78765       delete arg1;
78766     } catch (std::out_of_range& e) {
78767       {
78768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78769       };
78770     } catch (std::exception& e) {
78771       {
78772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78773       };
78774     } catch (Dali::DaliException e) {
78775       {
78776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78777       };
78778     } catch (...) {
78779       {
78780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78781       };
78782     }
78783   }
78784
78785 }
78786
78787
78788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
78789   void * jresult ;
78790   Dali::Toolkit::TableView *result = 0 ;
78791
78792   {
78793     try {
78794       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
78795     } catch (std::out_of_range& e) {
78796       {
78797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78798       };
78799     } catch (std::exception& e) {
78800       {
78801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78802       };
78803     } catch (Dali::DaliException e) {
78804       {
78805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78806       };
78807     } catch (...) {
78808       {
78809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78810       };
78811     }
78812   }
78813
78814   jresult = (void *)result;
78815   return jresult;
78816 }
78817
78818
78819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
78820   void * jresult ;
78821   Dali::Toolkit::TableView *arg1 = 0 ;
78822   Dali::Toolkit::TableView *result = 0 ;
78823
78824   arg1 = (Dali::Toolkit::TableView *)jarg1;
78825   if (!arg1) {
78826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
78827     return 0;
78828   }
78829   {
78830     try {
78831       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
78832     } catch (std::out_of_range& e) {
78833       {
78834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78835       };
78836     } catch (std::exception& e) {
78837       {
78838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78839       };
78840     } catch (Dali::DaliException e) {
78841       {
78842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78843       };
78844     } catch (...) {
78845       {
78846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78847       };
78848     }
78849   }
78850
78851   jresult = (void *)result;
78852   return jresult;
78853 }
78854
78855
78856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
78857   void * jresult ;
78858   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78859   Dali::Toolkit::TableView *arg2 = 0 ;
78860   Dali::Toolkit::TableView *result = 0 ;
78861
78862   arg1 = (Dali::Toolkit::TableView *)jarg1;
78863   arg2 = (Dali::Toolkit::TableView *)jarg2;
78864   if (!arg2) {
78865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
78866     return 0;
78867   }
78868   {
78869     try {
78870       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
78871     } catch (std::out_of_range& e) {
78872       {
78873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78874       };
78875     } catch (std::exception& e) {
78876       {
78877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78878       };
78879     } catch (Dali::DaliException e) {
78880       {
78881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78882       };
78883     } catch (...) {
78884       {
78885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78886       };
78887     }
78888   }
78889
78890   jresult = (void *)result;
78891   return jresult;
78892 }
78893
78894
78895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
78896   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78897
78898   arg1 = (Dali::Toolkit::TableView *)jarg1;
78899   {
78900     try {
78901       delete arg1;
78902     } catch (std::out_of_range& e) {
78903       {
78904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78905       };
78906     } catch (std::exception& e) {
78907       {
78908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78909       };
78910     } catch (Dali::DaliException e) {
78911       {
78912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78913       };
78914     } catch (...) {
78915       {
78916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78917       };
78918     }
78919   }
78920
78921 }
78922
78923
78924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
78925   void * jresult ;
78926   unsigned int arg1 ;
78927   unsigned int arg2 ;
78928   Dali::Toolkit::TableView result;
78929
78930   arg1 = (unsigned int)jarg1;
78931   arg2 = (unsigned int)jarg2;
78932   {
78933     try {
78934       result = Dali::Toolkit::TableView::New(arg1,arg2);
78935     } catch (std::out_of_range& e) {
78936       {
78937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78938       };
78939     } catch (std::exception& e) {
78940       {
78941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78942       };
78943     } catch (Dali::DaliException e) {
78944       {
78945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78946       };
78947     } catch (...) {
78948       {
78949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78950       };
78951     }
78952   }
78953
78954   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
78955   return jresult;
78956 }
78957
78958
78959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
78960   void * jresult ;
78961   Dali::BaseHandle arg1 ;
78962   Dali::BaseHandle *argp1 ;
78963   Dali::Toolkit::TableView result;
78964
78965   argp1 = (Dali::BaseHandle *)jarg1;
78966   if (!argp1) {
78967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78968     return 0;
78969   }
78970   arg1 = *argp1;
78971   {
78972     try {
78973       result = Dali::Toolkit::TableView::DownCast(arg1);
78974     } catch (std::out_of_range& e) {
78975       {
78976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78977       };
78978     } catch (std::exception& e) {
78979       {
78980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78981       };
78982     } catch (Dali::DaliException e) {
78983       {
78984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78985       };
78986     } catch (...) {
78987       {
78988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78989       };
78990     }
78991   }
78992
78993   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
78994   return jresult;
78995 }
78996
78997
78998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
78999   unsigned int jresult ;
79000   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79001   Dali::Actor arg2 ;
79002   Dali::Toolkit::TableView::CellPosition arg3 ;
79003   Dali::Actor *argp2 ;
79004   Dali::Toolkit::TableView::CellPosition *argp3 ;
79005   bool result;
79006
79007   arg1 = (Dali::Toolkit::TableView *)jarg1;
79008   argp2 = (Dali::Actor *)jarg2;
79009   if (!argp2) {
79010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79011     return 0;
79012   }
79013   arg2 = *argp2;
79014   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
79015   if (!argp3) {
79016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
79017     return 0;
79018   }
79019   arg3 = *argp3;
79020   {
79021     try {
79022       result = (bool)(arg1)->AddChild(arg2,arg3);
79023     } catch (std::out_of_range& e) {
79024       {
79025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79026       };
79027     } catch (std::exception& e) {
79028       {
79029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79030       };
79031     } catch (Dali::DaliException e) {
79032       {
79033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79034       };
79035     } catch (...) {
79036       {
79037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79038       };
79039     }
79040   }
79041
79042   jresult = result;
79043   return jresult;
79044 }
79045
79046
79047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
79048   void * jresult ;
79049   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79050   Dali::Toolkit::TableView::CellPosition arg2 ;
79051   Dali::Toolkit::TableView::CellPosition *argp2 ;
79052   Dali::Actor result;
79053
79054   arg1 = (Dali::Toolkit::TableView *)jarg1;
79055   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
79056   if (!argp2) {
79057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
79058     return 0;
79059   }
79060   arg2 = *argp2;
79061   {
79062     try {
79063       result = (arg1)->GetChildAt(arg2);
79064     } catch (std::out_of_range& e) {
79065       {
79066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79067       };
79068     } catch (std::exception& e) {
79069       {
79070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79071       };
79072     } catch (Dali::DaliException e) {
79073       {
79074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79075       };
79076     } catch (...) {
79077       {
79078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79079       };
79080     }
79081   }
79082
79083   jresult = new Dali::Actor((const Dali::Actor &)result);
79084   return jresult;
79085 }
79086
79087
79088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
79089   void * jresult ;
79090   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79091   Dali::Toolkit::TableView::CellPosition arg2 ;
79092   Dali::Toolkit::TableView::CellPosition *argp2 ;
79093   Dali::Actor result;
79094
79095   arg1 = (Dali::Toolkit::TableView *)jarg1;
79096   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
79097   if (!argp2) {
79098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
79099     return 0;
79100   }
79101   arg2 = *argp2;
79102   {
79103     try {
79104       result = (arg1)->RemoveChildAt(arg2);
79105     } catch (std::out_of_range& e) {
79106       {
79107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79108       };
79109     } catch (std::exception& e) {
79110       {
79111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79112       };
79113     } catch (Dali::DaliException e) {
79114       {
79115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79116       };
79117     } catch (...) {
79118       {
79119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79120       };
79121     }
79122   }
79123
79124   jresult = new Dali::Actor((const Dali::Actor &)result);
79125   return jresult;
79126 }
79127
79128
79129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
79130   unsigned int jresult ;
79131   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79132   Dali::Actor arg2 ;
79133   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
79134   Dali::Actor *argp2 ;
79135   bool result;
79136
79137   arg1 = (Dali::Toolkit::TableView *)jarg1;
79138   argp2 = (Dali::Actor *)jarg2;
79139   if (!argp2) {
79140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79141     return 0;
79142   }
79143   arg2 = *argp2;
79144   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
79145   if (!arg3) {
79146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
79147     return 0;
79148   }
79149   {
79150     try {
79151       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
79152     } catch (std::out_of_range& e) {
79153       {
79154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79155       };
79156     } catch (std::exception& e) {
79157       {
79158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79159       };
79160     } catch (Dali::DaliException e) {
79161       {
79162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79163       };
79164     } catch (...) {
79165       {
79166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79167       };
79168     }
79169   }
79170
79171   jresult = result;
79172   return jresult;
79173 }
79174
79175
79176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
79177   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79178   unsigned int arg2 ;
79179
79180   arg1 = (Dali::Toolkit::TableView *)jarg1;
79181   arg2 = (unsigned int)jarg2;
79182   {
79183     try {
79184       (arg1)->InsertRow(arg2);
79185     } catch (std::out_of_range& e) {
79186       {
79187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79188       };
79189     } catch (std::exception& e) {
79190       {
79191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79192       };
79193     } catch (Dali::DaliException e) {
79194       {
79195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79196       };
79197     } catch (...) {
79198       {
79199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79200       };
79201     }
79202   }
79203
79204 }
79205
79206
79207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
79208   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79209   unsigned int arg2 ;
79210
79211   arg1 = (Dali::Toolkit::TableView *)jarg1;
79212   arg2 = (unsigned int)jarg2;
79213   {
79214     try {
79215       (arg1)->DeleteRow(arg2);
79216     } catch (std::out_of_range& e) {
79217       {
79218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79219       };
79220     } catch (std::exception& e) {
79221       {
79222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79223       };
79224     } catch (Dali::DaliException e) {
79225       {
79226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79227       };
79228     } catch (...) {
79229       {
79230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79231       };
79232     }
79233   }
79234
79235 }
79236
79237
79238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
79239   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79240   unsigned int arg2 ;
79241   std::vector< Dali::Actor > *arg3 = 0 ;
79242
79243   arg1 = (Dali::Toolkit::TableView *)jarg1;
79244   arg2 = (unsigned int)jarg2;
79245   arg3 = (std::vector< Dali::Actor > *)jarg3;
79246   if (!arg3) {
79247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
79248     return ;
79249   }
79250   {
79251     try {
79252       (arg1)->DeleteRow(arg2,*arg3);
79253     } catch (std::out_of_range& e) {
79254       {
79255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79256       };
79257     } catch (std::exception& e) {
79258       {
79259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79260       };
79261     } catch (Dali::DaliException e) {
79262       {
79263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79264       };
79265     } catch (...) {
79266       {
79267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79268       };
79269     }
79270   }
79271
79272 }
79273
79274
79275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
79276   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79277   unsigned int arg2 ;
79278
79279   arg1 = (Dali::Toolkit::TableView *)jarg1;
79280   arg2 = (unsigned int)jarg2;
79281   {
79282     try {
79283       (arg1)->InsertColumn(arg2);
79284     } catch (std::out_of_range& e) {
79285       {
79286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79287       };
79288     } catch (std::exception& e) {
79289       {
79290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79291       };
79292     } catch (Dali::DaliException e) {
79293       {
79294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79295       };
79296     } catch (...) {
79297       {
79298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79299       };
79300     }
79301   }
79302
79303 }
79304
79305
79306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
79307   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79308   unsigned int arg2 ;
79309
79310   arg1 = (Dali::Toolkit::TableView *)jarg1;
79311   arg2 = (unsigned int)jarg2;
79312   {
79313     try {
79314       (arg1)->DeleteColumn(arg2);
79315     } catch (std::out_of_range& e) {
79316       {
79317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79318       };
79319     } catch (std::exception& e) {
79320       {
79321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79322       };
79323     } catch (Dali::DaliException e) {
79324       {
79325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79326       };
79327     } catch (...) {
79328       {
79329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79330       };
79331     }
79332   }
79333
79334 }
79335
79336
79337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
79338   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79339   unsigned int arg2 ;
79340   std::vector< Dali::Actor > *arg3 = 0 ;
79341
79342   arg1 = (Dali::Toolkit::TableView *)jarg1;
79343   arg2 = (unsigned int)jarg2;
79344   arg3 = (std::vector< Dali::Actor > *)jarg3;
79345   if (!arg3) {
79346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
79347     return ;
79348   }
79349   {
79350     try {
79351       (arg1)->DeleteColumn(arg2,*arg3);
79352     } catch (std::out_of_range& e) {
79353       {
79354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79355       };
79356     } catch (std::exception& e) {
79357       {
79358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79359       };
79360     } catch (Dali::DaliException e) {
79361       {
79362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79363       };
79364     } catch (...) {
79365       {
79366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79367       };
79368     }
79369   }
79370
79371 }
79372
79373
79374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
79375   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79376   unsigned int arg2 ;
79377   unsigned int arg3 ;
79378
79379   arg1 = (Dali::Toolkit::TableView *)jarg1;
79380   arg2 = (unsigned int)jarg2;
79381   arg3 = (unsigned int)jarg3;
79382   {
79383     try {
79384       (arg1)->Resize(arg2,arg3);
79385     } catch (std::out_of_range& e) {
79386       {
79387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79388       };
79389     } catch (std::exception& e) {
79390       {
79391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79392       };
79393     } catch (Dali::DaliException e) {
79394       {
79395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79396       };
79397     } catch (...) {
79398       {
79399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79400       };
79401     }
79402   }
79403
79404 }
79405
79406
79407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
79408   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79409   unsigned int arg2 ;
79410   unsigned int arg3 ;
79411   std::vector< Dali::Actor > *arg4 = 0 ;
79412
79413   arg1 = (Dali::Toolkit::TableView *)jarg1;
79414   arg2 = (unsigned int)jarg2;
79415   arg3 = (unsigned int)jarg3;
79416   arg4 = (std::vector< Dali::Actor > *)jarg4;
79417   if (!arg4) {
79418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
79419     return ;
79420   }
79421   {
79422     try {
79423       (arg1)->Resize(arg2,arg3,*arg4);
79424     } catch (std::out_of_range& e) {
79425       {
79426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79427       };
79428     } catch (std::exception& e) {
79429       {
79430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79431       };
79432     } catch (Dali::DaliException e) {
79433       {
79434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79435       };
79436     } catch (...) {
79437       {
79438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79439       };
79440     }
79441   }
79442
79443 }
79444
79445
79446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
79447   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79448   Dali::Size arg2 ;
79449   Dali::Size *argp2 ;
79450
79451   arg1 = (Dali::Toolkit::TableView *)jarg1;
79452   argp2 = (Dali::Size *)jarg2;
79453   if (!argp2) {
79454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
79455     return ;
79456   }
79457   arg2 = *argp2;
79458   {
79459     try {
79460       (arg1)->SetCellPadding(arg2);
79461     } catch (std::out_of_range& e) {
79462       {
79463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79464       };
79465     } catch (std::exception& e) {
79466       {
79467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79468       };
79469     } catch (Dali::DaliException e) {
79470       {
79471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79472       };
79473     } catch (...) {
79474       {
79475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79476       };
79477     }
79478   }
79479
79480 }
79481
79482
79483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
79484   void * jresult ;
79485   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79486   Dali::Size result;
79487
79488   arg1 = (Dali::Toolkit::TableView *)jarg1;
79489   {
79490     try {
79491       result = (arg1)->GetCellPadding();
79492     } catch (std::out_of_range& e) {
79493       {
79494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79495       };
79496     } catch (std::exception& e) {
79497       {
79498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79499       };
79500     } catch (Dali::DaliException e) {
79501       {
79502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79503       };
79504     } catch (...) {
79505       {
79506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79507       };
79508     }
79509   }
79510
79511   jresult = new Dali::Size((const Dali::Size &)result);
79512   return jresult;
79513 }
79514
79515
79516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
79517   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79518   unsigned int arg2 ;
79519
79520   arg1 = (Dali::Toolkit::TableView *)jarg1;
79521   arg2 = (unsigned int)jarg2;
79522   {
79523     try {
79524       (arg1)->SetFitHeight(arg2);
79525     } catch (std::out_of_range& e) {
79526       {
79527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79528       };
79529     } catch (std::exception& e) {
79530       {
79531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79532       };
79533     } catch (Dali::DaliException e) {
79534       {
79535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79536       };
79537     } catch (...) {
79538       {
79539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79540       };
79541     }
79542   }
79543
79544 }
79545
79546
79547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
79548   unsigned int jresult ;
79549   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79550   unsigned int arg2 ;
79551   bool result;
79552
79553   arg1 = (Dali::Toolkit::TableView *)jarg1;
79554   arg2 = (unsigned int)jarg2;
79555   {
79556     try {
79557       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
79558     } catch (std::out_of_range& e) {
79559       {
79560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79561       };
79562     } catch (std::exception& e) {
79563       {
79564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79565       };
79566     } catch (Dali::DaliException e) {
79567       {
79568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79569       };
79570     } catch (...) {
79571       {
79572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79573       };
79574     }
79575   }
79576
79577   jresult = result;
79578   return jresult;
79579 }
79580
79581
79582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
79583   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79584   unsigned int arg2 ;
79585
79586   arg1 = (Dali::Toolkit::TableView *)jarg1;
79587   arg2 = (unsigned int)jarg2;
79588   {
79589     try {
79590       (arg1)->SetFitWidth(arg2);
79591     } catch (std::out_of_range& e) {
79592       {
79593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79594       };
79595     } catch (std::exception& e) {
79596       {
79597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79598       };
79599     } catch (Dali::DaliException e) {
79600       {
79601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79602       };
79603     } catch (...) {
79604       {
79605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79606       };
79607     }
79608   }
79609
79610 }
79611
79612
79613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
79614   unsigned int jresult ;
79615   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79616   unsigned int arg2 ;
79617   bool result;
79618
79619   arg1 = (Dali::Toolkit::TableView *)jarg1;
79620   arg2 = (unsigned int)jarg2;
79621   {
79622     try {
79623       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
79624     } catch (std::out_of_range& e) {
79625       {
79626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79627       };
79628     } catch (std::exception& e) {
79629       {
79630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79631       };
79632     } catch (Dali::DaliException e) {
79633       {
79634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79635       };
79636     } catch (...) {
79637       {
79638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79639       };
79640     }
79641   }
79642
79643   jresult = result;
79644   return jresult;
79645 }
79646
79647
79648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
79649   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79650   unsigned int arg2 ;
79651   float arg3 ;
79652
79653   arg1 = (Dali::Toolkit::TableView *)jarg1;
79654   arg2 = (unsigned int)jarg2;
79655   arg3 = (float)jarg3;
79656   {
79657     try {
79658       (arg1)->SetFixedHeight(arg2,arg3);
79659     } catch (std::out_of_range& e) {
79660       {
79661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79662       };
79663     } catch (std::exception& e) {
79664       {
79665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79666       };
79667     } catch (Dali::DaliException e) {
79668       {
79669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79670       };
79671     } catch (...) {
79672       {
79673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79674       };
79675     }
79676   }
79677
79678 }
79679
79680
79681 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
79682   float jresult ;
79683   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79684   unsigned int arg2 ;
79685   float result;
79686
79687   arg1 = (Dali::Toolkit::TableView *)jarg1;
79688   arg2 = (unsigned int)jarg2;
79689   {
79690     try {
79691       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
79692     } catch (std::out_of_range& e) {
79693       {
79694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79695       };
79696     } catch (std::exception& e) {
79697       {
79698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79699       };
79700     } catch (Dali::DaliException e) {
79701       {
79702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79703       };
79704     } catch (...) {
79705       {
79706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79707       };
79708     }
79709   }
79710
79711   jresult = result;
79712   return jresult;
79713 }
79714
79715
79716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
79717   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79718   unsigned int arg2 ;
79719   float arg3 ;
79720
79721   arg1 = (Dali::Toolkit::TableView *)jarg1;
79722   arg2 = (unsigned int)jarg2;
79723   arg3 = (float)jarg3;
79724   {
79725     try {
79726       (arg1)->SetRelativeHeight(arg2,arg3);
79727     } catch (std::out_of_range& e) {
79728       {
79729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79730       };
79731     } catch (std::exception& e) {
79732       {
79733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79734       };
79735     } catch (Dali::DaliException e) {
79736       {
79737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79738       };
79739     } catch (...) {
79740       {
79741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79742       };
79743     }
79744   }
79745
79746 }
79747
79748
79749 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
79750   float jresult ;
79751   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79752   unsigned int arg2 ;
79753   float result;
79754
79755   arg1 = (Dali::Toolkit::TableView *)jarg1;
79756   arg2 = (unsigned int)jarg2;
79757   {
79758     try {
79759       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
79760     } catch (std::out_of_range& e) {
79761       {
79762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79763       };
79764     } catch (std::exception& e) {
79765       {
79766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79767       };
79768     } catch (Dali::DaliException e) {
79769       {
79770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79771       };
79772     } catch (...) {
79773       {
79774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79775       };
79776     }
79777   }
79778
79779   jresult = result;
79780   return jresult;
79781 }
79782
79783
79784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
79785   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79786   unsigned int arg2 ;
79787   float arg3 ;
79788
79789   arg1 = (Dali::Toolkit::TableView *)jarg1;
79790   arg2 = (unsigned int)jarg2;
79791   arg3 = (float)jarg3;
79792   {
79793     try {
79794       (arg1)->SetFixedWidth(arg2,arg3);
79795     } catch (std::out_of_range& e) {
79796       {
79797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79798       };
79799     } catch (std::exception& e) {
79800       {
79801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79802       };
79803     } catch (Dali::DaliException e) {
79804       {
79805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79806       };
79807     } catch (...) {
79808       {
79809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79810       };
79811     }
79812   }
79813
79814 }
79815
79816
79817 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
79818   float jresult ;
79819   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79820   unsigned int arg2 ;
79821   float result;
79822
79823   arg1 = (Dali::Toolkit::TableView *)jarg1;
79824   arg2 = (unsigned int)jarg2;
79825   {
79826     try {
79827       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
79828     } catch (std::out_of_range& e) {
79829       {
79830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79831       };
79832     } catch (std::exception& e) {
79833       {
79834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79835       };
79836     } catch (Dali::DaliException e) {
79837       {
79838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79839       };
79840     } catch (...) {
79841       {
79842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79843       };
79844     }
79845   }
79846
79847   jresult = result;
79848   return jresult;
79849 }
79850
79851
79852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
79853   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79854   unsigned int arg2 ;
79855   float arg3 ;
79856
79857   arg1 = (Dali::Toolkit::TableView *)jarg1;
79858   arg2 = (unsigned int)jarg2;
79859   arg3 = (float)jarg3;
79860   {
79861     try {
79862       (arg1)->SetRelativeWidth(arg2,arg3);
79863     } catch (std::out_of_range& e) {
79864       {
79865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79866       };
79867     } catch (std::exception& e) {
79868       {
79869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79870       };
79871     } catch (Dali::DaliException e) {
79872       {
79873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79874       };
79875     } catch (...) {
79876       {
79877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79878       };
79879     }
79880   }
79881
79882 }
79883
79884
79885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
79886   float jresult ;
79887   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79888   unsigned int arg2 ;
79889   float result;
79890
79891   arg1 = (Dali::Toolkit::TableView *)jarg1;
79892   arg2 = (unsigned int)jarg2;
79893   {
79894     try {
79895       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
79896     } catch (std::out_of_range& e) {
79897       {
79898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79899       };
79900     } catch (std::exception& e) {
79901       {
79902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79903       };
79904     } catch (Dali::DaliException e) {
79905       {
79906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79907       };
79908     } catch (...) {
79909       {
79910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79911       };
79912     }
79913   }
79914
79915   jresult = result;
79916   return jresult;
79917 }
79918
79919
79920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
79921   unsigned int jresult ;
79922   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79923   unsigned int result;
79924
79925   arg1 = (Dali::Toolkit::TableView *)jarg1;
79926   {
79927     try {
79928       result = (unsigned int)(arg1)->GetRows();
79929     } catch (std::out_of_range& e) {
79930       {
79931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79932       };
79933     } catch (std::exception& e) {
79934       {
79935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79936       };
79937     } catch (Dali::DaliException e) {
79938       {
79939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79940       };
79941     } catch (...) {
79942       {
79943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79944       };
79945     }
79946   }
79947
79948   jresult = result;
79949   return jresult;
79950 }
79951
79952
79953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
79954   unsigned int jresult ;
79955   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79956   unsigned int result;
79957
79958   arg1 = (Dali::Toolkit::TableView *)jarg1;
79959   {
79960     try {
79961       result = (unsigned int)(arg1)->GetColumns();
79962     } catch (std::out_of_range& e) {
79963       {
79964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79965       };
79966     } catch (std::exception& e) {
79967       {
79968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79969       };
79970     } catch (Dali::DaliException e) {
79971       {
79972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79973       };
79974     } catch (...) {
79975       {
79976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79977       };
79978     }
79979   }
79980
79981   jresult = result;
79982   return jresult;
79983 }
79984
79985
79986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
79987   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79988   Dali::Toolkit::TableView::CellPosition arg2 ;
79989   Dali::HorizontalAlignment::Type arg3 ;
79990   Dali::VerticalAlignment::Type arg4 ;
79991   Dali::Toolkit::TableView::CellPosition *argp2 ;
79992
79993   arg1 = (Dali::Toolkit::TableView *)jarg1;
79994   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
79995   if (!argp2) {
79996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
79997     return ;
79998   }
79999   arg2 = *argp2;
80000   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
80001   arg4 = (Dali::VerticalAlignment::Type)jarg4;
80002   {
80003     try {
80004       (arg1)->SetCellAlignment(arg2,arg3,arg4);
80005     } catch (std::out_of_range& e) {
80006       {
80007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80008       };
80009     } catch (std::exception& e) {
80010       {
80011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80012       };
80013     } catch (Dali::DaliException e) {
80014       {
80015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80016       };
80017     } catch (...) {
80018       {
80019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80020       };
80021     }
80022   }
80023
80024 }
80025
80026
80027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
80028   unsigned int jresult ;
80029   unsigned int result;
80030
80031   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
80032   jresult = result;
80033   return jresult;
80034 }
80035
80036
80037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
80038   int jresult ;
80039   int result;
80040
80041   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
80042   jresult = (int)result;
80043   return jresult;
80044 }
80045
80046
80047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
80048   int jresult ;
80049   int result;
80050
80051   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
80052   jresult = (int)result;
80053   return jresult;
80054 }
80055
80056
80057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
80058   int jresult ;
80059   int result;
80060
80061   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
80062   jresult = (int)result;
80063   return jresult;
80064 }
80065
80066
80067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
80068   int jresult ;
80069   int result;
80070
80071   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
80072   jresult = (int)result;
80073   return jresult;
80074 }
80075
80076
80077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
80078   int jresult ;
80079   int result;
80080
80081   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
80082   jresult = (int)result;
80083   return jresult;
80084 }
80085
80086
80087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
80088   int jresult ;
80089   int result;
80090
80091   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
80092   jresult = (int)result;
80093   return jresult;
80094 }
80095
80096
80097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
80098   int jresult ;
80099   int result;
80100
80101   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
80102   jresult = (int)result;
80103   return jresult;
80104 }
80105
80106
80107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
80108   int jresult ;
80109   int result;
80110
80111   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
80112   jresult = (int)result;
80113   return jresult;
80114 }
80115
80116
80117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
80118   int jresult ;
80119   int result;
80120
80121   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
80122   jresult = (int)result;
80123   return jresult;
80124 }
80125
80126
80127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
80128   int jresult ;
80129   int result;
80130
80131   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
80132   jresult = (int)result;
80133   return jresult;
80134 }
80135
80136
80137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
80138   int jresult ;
80139   int result;
80140
80141   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
80142   jresult = (int)result;
80143   return jresult;
80144 }
80145
80146
80147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
80148   int jresult ;
80149   int result;
80150
80151   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
80152   jresult = (int)result;
80153   return jresult;
80154 }
80155
80156
80157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
80158   int jresult ;
80159   int result;
80160
80161   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
80162   jresult = (int)result;
80163   return jresult;
80164 }
80165
80166
80167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
80168   int jresult ;
80169   int result;
80170
80171   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
80172   jresult = (int)result;
80173   return jresult;
80174 }
80175
80176
80177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
80178   int jresult ;
80179   int result;
80180
80181   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
80182   jresult = (int)result;
80183   return jresult;
80184 }
80185
80186
80187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
80188   int jresult ;
80189   int result;
80190
80191   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
80192   jresult = (int)result;
80193   return jresult;
80194 }
80195
80196
80197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
80198   int jresult ;
80199   int result;
80200
80201   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
80202   jresult = (int)result;
80203   return jresult;
80204 }
80205
80206
80207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
80208   int jresult ;
80209   int result;
80210
80211   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
80212   jresult = (int)result;
80213   return jresult;
80214 }
80215
80216
80217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
80218   int jresult ;
80219   int result;
80220
80221   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
80222   jresult = (int)result;
80223   return jresult;
80224 }
80225
80226
80227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
80228   void * jresult ;
80229   Dali::Toolkit::TextLabel::Property *result = 0 ;
80230
80231   {
80232     try {
80233       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
80234     } catch (std::out_of_range& e) {
80235       {
80236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80237       };
80238     } catch (std::exception& e) {
80239       {
80240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80241       };
80242     } catch (Dali::DaliException e) {
80243       {
80244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80245       };
80246     } catch (...) {
80247       {
80248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80249       };
80250     }
80251   }
80252
80253   jresult = (void *)result;
80254   return jresult;
80255 }
80256
80257
80258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
80259   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
80260
80261   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
80262   {
80263     try {
80264       delete arg1;
80265     } catch (std::out_of_range& e) {
80266       {
80267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80268       };
80269     } catch (std::exception& e) {
80270       {
80271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80272       };
80273     } catch (Dali::DaliException e) {
80274       {
80275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80276       };
80277     } catch (...) {
80278       {
80279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80280       };
80281     }
80282   }
80283
80284 }
80285
80286
80287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
80288   void * jresult ;
80289   Dali::Toolkit::TextLabel result;
80290
80291   {
80292     try {
80293       result = Dali::Toolkit::TextLabel::New();
80294     } catch (std::out_of_range& e) {
80295       {
80296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80297       };
80298     } catch (std::exception& e) {
80299       {
80300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80301       };
80302     } catch (Dali::DaliException e) {
80303       {
80304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80305       };
80306     } catch (...) {
80307       {
80308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80309       };
80310     }
80311   }
80312
80313   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
80314   return jresult;
80315 }
80316
80317
80318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
80319   void * jresult ;
80320   std::string *arg1 = 0 ;
80321   Dali::Toolkit::TextLabel result;
80322
80323   if (!jarg1) {
80324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80325     return 0;
80326   }
80327   std::string arg1_str(jarg1);
80328   arg1 = &arg1_str;
80329   {
80330     try {
80331       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
80332     } catch (std::out_of_range& e) {
80333       {
80334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80335       };
80336     } catch (std::exception& e) {
80337       {
80338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80339       };
80340     } catch (Dali::DaliException e) {
80341       {
80342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80343       };
80344     } catch (...) {
80345       {
80346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80347       };
80348     }
80349   }
80350
80351   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
80352
80353   //argout typemap for const std::string&
80354
80355   return jresult;
80356 }
80357
80358
80359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
80360   void * jresult ;
80361   Dali::Toolkit::TextLabel *result = 0 ;
80362
80363   {
80364     try {
80365       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
80366     } catch (std::out_of_range& e) {
80367       {
80368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80369       };
80370     } catch (std::exception& e) {
80371       {
80372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80373       };
80374     } catch (Dali::DaliException e) {
80375       {
80376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80377       };
80378     } catch (...) {
80379       {
80380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80381       };
80382     }
80383   }
80384
80385   jresult = (void *)result;
80386   return jresult;
80387 }
80388
80389
80390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
80391   void * jresult ;
80392   Dali::Toolkit::TextLabel *arg1 = 0 ;
80393   Dali::Toolkit::TextLabel *result = 0 ;
80394
80395   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
80396   if (!arg1) {
80397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
80398     return 0;
80399   }
80400   {
80401     try {
80402       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
80403     } catch (std::out_of_range& e) {
80404       {
80405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80406       };
80407     } catch (std::exception& e) {
80408       {
80409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80410       };
80411     } catch (Dali::DaliException e) {
80412       {
80413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80414       };
80415     } catch (...) {
80416       {
80417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80418       };
80419     }
80420   }
80421
80422   jresult = (void *)result;
80423   return jresult;
80424 }
80425
80426
80427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
80428   void * jresult ;
80429   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
80430   Dali::Toolkit::TextLabel *arg2 = 0 ;
80431   Dali::Toolkit::TextLabel *result = 0 ;
80432
80433   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
80434   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
80435   if (!arg2) {
80436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
80437     return 0;
80438   }
80439   {
80440     try {
80441       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
80442     } catch (std::out_of_range& e) {
80443       {
80444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80445       };
80446     } catch (std::exception& e) {
80447       {
80448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80449       };
80450     } catch (Dali::DaliException e) {
80451       {
80452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80453       };
80454     } catch (...) {
80455       {
80456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80457       };
80458     }
80459   }
80460
80461   jresult = (void *)result;
80462   return jresult;
80463 }
80464
80465
80466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
80467   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
80468
80469   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
80470   {
80471     try {
80472       delete arg1;
80473     } catch (std::out_of_range& e) {
80474       {
80475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80476       };
80477     } catch (std::exception& e) {
80478       {
80479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80480       };
80481     } catch (Dali::DaliException e) {
80482       {
80483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80484       };
80485     } catch (...) {
80486       {
80487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80488       };
80489     }
80490   }
80491
80492 }
80493
80494
80495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
80496   void * jresult ;
80497   Dali::BaseHandle arg1 ;
80498   Dali::BaseHandle *argp1 ;
80499   Dali::Toolkit::TextLabel result;
80500
80501   argp1 = (Dali::BaseHandle *)jarg1;
80502   if (!argp1) {
80503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80504     return 0;
80505   }
80506   arg1 = *argp1;
80507   {
80508     try {
80509       result = Dali::Toolkit::TextLabel::DownCast(arg1);
80510     } catch (std::out_of_range& e) {
80511       {
80512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80513       };
80514     } catch (std::exception& e) {
80515       {
80516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80517       };
80518     } catch (Dali::DaliException e) {
80519       {
80520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80521       };
80522     } catch (...) {
80523       {
80524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80525       };
80526     }
80527   }
80528
80529   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
80530   return jresult;
80531 }
80532
80533
80534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
80535   void * jresult ;
80536   Dali::Toolkit::AccessibilityManager *result = 0 ;
80537
80538   {
80539     try {
80540       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
80541     } catch (std::out_of_range& e) {
80542       {
80543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80544       };
80545     } catch (std::exception& e) {
80546       {
80547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80548       };
80549     } catch (Dali::DaliException e) {
80550       {
80551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80552       };
80553     } catch (...) {
80554       {
80555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80556       };
80557     }
80558   }
80559
80560   jresult = (void *)result;
80561   return jresult;
80562 }
80563
80564
80565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
80566   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80567
80568   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80569   {
80570     try {
80571       delete arg1;
80572     } catch (std::out_of_range& e) {
80573       {
80574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80575       };
80576     } catch (std::exception& e) {
80577       {
80578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80579       };
80580     } catch (Dali::DaliException e) {
80581       {
80582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80583       };
80584     } catch (...) {
80585       {
80586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80587       };
80588     }
80589   }
80590
80591 }
80592
80593
80594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
80595   void * jresult ;
80596   Dali::Toolkit::AccessibilityManager result;
80597
80598   {
80599     try {
80600       result = Dali::Toolkit::AccessibilityManager::Get();
80601     } catch (std::out_of_range& e) {
80602       {
80603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80604       };
80605     } catch (std::exception& e) {
80606       {
80607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80608       };
80609     } catch (Dali::DaliException e) {
80610       {
80611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80612       };
80613     } catch (...) {
80614       {
80615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80616       };
80617     }
80618   }
80619
80620   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
80621   return jresult;
80622 }
80623
80624
80625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
80626   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80627   Dali::Actor arg2 ;
80628   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
80629   std::string *arg4 = 0 ;
80630   Dali::Actor *argp2 ;
80631
80632   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80633   argp2 = (Dali::Actor *)jarg2;
80634   if (!argp2) {
80635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80636     return ;
80637   }
80638   arg2 = *argp2;
80639   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
80640   if (!jarg4) {
80641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80642     return ;
80643   }
80644   std::string arg4_str(jarg4);
80645   arg4 = &arg4_str;
80646   {
80647     try {
80648       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
80649     } catch (std::out_of_range& e) {
80650       {
80651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80652       };
80653     } catch (std::exception& e) {
80654       {
80655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80656       };
80657     } catch (Dali::DaliException e) {
80658       {
80659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80660       };
80661     } catch (...) {
80662       {
80663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80664       };
80665     }
80666   }
80667
80668
80669   //argout typemap for const std::string&
80670
80671 }
80672
80673
80674 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
80675   char * jresult ;
80676   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80677   Dali::Actor arg2 ;
80678   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
80679   Dali::Actor *argp2 ;
80680   std::string result;
80681
80682   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80683   argp2 = (Dali::Actor *)jarg2;
80684   if (!argp2) {
80685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80686     return 0;
80687   }
80688   arg2 = *argp2;
80689   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
80690   {
80691     try {
80692       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
80693     } catch (std::out_of_range& e) {
80694       {
80695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80696       };
80697     } catch (std::exception& e) {
80698       {
80699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80700       };
80701     } catch (Dali::DaliException e) {
80702       {
80703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80704       };
80705     } catch (...) {
80706       {
80707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80708       };
80709     }
80710   }
80711
80712   jresult = SWIG_csharp_string_callback((&result)->c_str());
80713   return jresult;
80714 }
80715
80716
80717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
80718   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80719   Dali::Actor arg2 ;
80720   unsigned int arg3 ;
80721   Dali::Actor *argp2 ;
80722
80723   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80724   argp2 = (Dali::Actor *)jarg2;
80725   if (!argp2) {
80726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80727     return ;
80728   }
80729   arg2 = *argp2;
80730   arg3 = (unsigned int)jarg3;
80731   {
80732     try {
80733       (arg1)->SetFocusOrder(arg2,arg3);
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 unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
80757   unsigned int jresult ;
80758   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80759   Dali::Actor arg2 ;
80760   Dali::Actor *argp2 ;
80761   unsigned int result;
80762
80763   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80764   argp2 = (Dali::Actor *)jarg2;
80765   if (!argp2) {
80766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80767     return 0;
80768   }
80769   arg2 = *argp2;
80770   {
80771     try {
80772       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
80773     } catch (std::out_of_range& e) {
80774       {
80775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80776       };
80777     } catch (std::exception& e) {
80778       {
80779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80780       };
80781     } catch (Dali::DaliException e) {
80782       {
80783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80784       };
80785     } catch (...) {
80786       {
80787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80788       };
80789     }
80790   }
80791
80792   jresult = result;
80793   return jresult;
80794 }
80795
80796
80797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
80798   unsigned int jresult ;
80799   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80800   unsigned int result;
80801
80802   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80803   {
80804     try {
80805       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
80806     } catch (std::out_of_range& e) {
80807       {
80808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80809       };
80810     } catch (std::exception& e) {
80811       {
80812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80813       };
80814     } catch (Dali::DaliException e) {
80815       {
80816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80817       };
80818     } catch (...) {
80819       {
80820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80821       };
80822     }
80823   }
80824
80825   jresult = result;
80826   return jresult;
80827 }
80828
80829
80830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
80831   void * jresult ;
80832   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80833   unsigned int arg2 ;
80834   Dali::Actor result;
80835
80836   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80837   arg2 = (unsigned int)jarg2;
80838   {
80839     try {
80840       result = (arg1)->GetActorByFocusOrder(arg2);
80841     } catch (std::out_of_range& e) {
80842       {
80843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80844       };
80845     } catch (std::exception& e) {
80846       {
80847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80848       };
80849     } catch (Dali::DaliException e) {
80850       {
80851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80852       };
80853     } catch (...) {
80854       {
80855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80856       };
80857     }
80858   }
80859
80860   jresult = new Dali::Actor((const Dali::Actor &)result);
80861   return jresult;
80862 }
80863
80864
80865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
80866   unsigned int jresult ;
80867   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80868   Dali::Actor arg2 ;
80869   Dali::Actor *argp2 ;
80870   bool result;
80871
80872   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80873   argp2 = (Dali::Actor *)jarg2;
80874   if (!argp2) {
80875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80876     return 0;
80877   }
80878   arg2 = *argp2;
80879   {
80880     try {
80881       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
80882     } catch (std::out_of_range& e) {
80883       {
80884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80885       };
80886     } catch (std::exception& e) {
80887       {
80888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80889       };
80890     } catch (Dali::DaliException e) {
80891       {
80892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80893       };
80894     } catch (...) {
80895       {
80896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80897       };
80898     }
80899   }
80900
80901   jresult = result;
80902   return jresult;
80903 }
80904
80905
80906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
80907   void * jresult ;
80908   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80909   Dali::Actor result;
80910
80911   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80912   {
80913     try {
80914       result = (arg1)->GetCurrentFocusActor();
80915     } catch (std::out_of_range& e) {
80916       {
80917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80918       };
80919     } catch (std::exception& e) {
80920       {
80921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80922       };
80923     } catch (Dali::DaliException e) {
80924       {
80925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80926       };
80927     } catch (...) {
80928       {
80929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80930       };
80931     }
80932   }
80933
80934   jresult = new Dali::Actor((const Dali::Actor &)result);
80935   return jresult;
80936 }
80937
80938
80939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
80940   void * jresult ;
80941   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80942   Dali::Actor result;
80943
80944   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80945   {
80946     try {
80947       result = (arg1)->GetCurrentFocusGroup();
80948     } catch (std::out_of_range& e) {
80949       {
80950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80951       };
80952     } catch (std::exception& e) {
80953       {
80954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80955       };
80956     } catch (Dali::DaliException e) {
80957       {
80958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80959       };
80960     } catch (...) {
80961       {
80962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80963       };
80964     }
80965   }
80966
80967   jresult = new Dali::Actor((const Dali::Actor &)result);
80968   return jresult;
80969 }
80970
80971
80972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
80973   unsigned int jresult ;
80974   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80975   unsigned int result;
80976
80977   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80978   {
80979     try {
80980       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
80981     } catch (std::out_of_range& e) {
80982       {
80983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80984       };
80985     } catch (std::exception& e) {
80986       {
80987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80988       };
80989     } catch (Dali::DaliException e) {
80990       {
80991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80992       };
80993     } catch (...) {
80994       {
80995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80996       };
80997     }
80998   }
80999
81000   jresult = result;
81001   return jresult;
81002 }
81003
81004
81005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
81006   unsigned int jresult ;
81007   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81008   bool result;
81009
81010   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81011   {
81012     try {
81013       result = (bool)(arg1)->MoveFocusForward();
81014     } catch (std::out_of_range& e) {
81015       {
81016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81017       };
81018     } catch (std::exception& e) {
81019       {
81020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81021       };
81022     } catch (Dali::DaliException e) {
81023       {
81024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81025       };
81026     } catch (...) {
81027       {
81028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81029       };
81030     }
81031   }
81032
81033   jresult = result;
81034   return jresult;
81035 }
81036
81037
81038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
81039   unsigned int jresult ;
81040   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81041   bool result;
81042
81043   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81044   {
81045     try {
81046       result = (bool)(arg1)->MoveFocusBackward();
81047     } catch (std::out_of_range& e) {
81048       {
81049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81050       };
81051     } catch (std::exception& e) {
81052       {
81053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81054       };
81055     } catch (Dali::DaliException e) {
81056       {
81057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81058       };
81059     } catch (...) {
81060       {
81061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81062       };
81063     }
81064   }
81065
81066   jresult = result;
81067   return jresult;
81068 }
81069
81070
81071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
81072   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81073
81074   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81075   {
81076     try {
81077       (arg1)->ClearFocus();
81078     } catch (std::out_of_range& e) {
81079       {
81080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81081       };
81082     } catch (std::exception& e) {
81083       {
81084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81085       };
81086     } catch (Dali::DaliException e) {
81087       {
81088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81089       };
81090     } catch (...) {
81091       {
81092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81093       };
81094     }
81095   }
81096
81097 }
81098
81099
81100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
81101   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81102
81103   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81104   {
81105     try {
81106       (arg1)->Reset();
81107     } catch (std::out_of_range& e) {
81108       {
81109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81110       };
81111     } catch (std::exception& e) {
81112       {
81113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81114       };
81115     } catch (Dali::DaliException e) {
81116       {
81117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81118       };
81119     } catch (...) {
81120       {
81121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81122       };
81123     }
81124   }
81125
81126 }
81127
81128
81129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
81130   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81131   Dali::Actor arg2 ;
81132   bool arg3 ;
81133   Dali::Actor *argp2 ;
81134
81135   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81136   argp2 = (Dali::Actor *)jarg2;
81137   if (!argp2) {
81138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81139     return ;
81140   }
81141   arg2 = *argp2;
81142   arg3 = jarg3 ? true : false;
81143   {
81144     try {
81145       (arg1)->SetFocusGroup(arg2,arg3);
81146     } catch (std::out_of_range& e) {
81147       {
81148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81149       };
81150     } catch (std::exception& e) {
81151       {
81152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81153       };
81154     } catch (Dali::DaliException e) {
81155       {
81156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81157       };
81158     } catch (...) {
81159       {
81160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81161       };
81162     }
81163   }
81164
81165 }
81166
81167
81168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
81169   unsigned int jresult ;
81170   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81171   Dali::Actor arg2 ;
81172   Dali::Actor *argp2 ;
81173   bool result;
81174
81175   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81176   argp2 = (Dali::Actor *)jarg2;
81177   if (!argp2) {
81178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81179     return 0;
81180   }
81181   arg2 = *argp2;
81182   {
81183     try {
81184       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
81185     } catch (std::out_of_range& e) {
81186       {
81187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81188       };
81189     } catch (std::exception& e) {
81190       {
81191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81192       };
81193     } catch (Dali::DaliException e) {
81194       {
81195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81196       };
81197     } catch (...) {
81198       {
81199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81200       };
81201     }
81202   }
81203
81204   jresult = result;
81205   return jresult;
81206 }
81207
81208
81209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
81210   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81211   bool arg2 ;
81212
81213   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81214   arg2 = jarg2 ? true : false;
81215   {
81216     try {
81217       (arg1)->SetGroupMode(arg2);
81218     } catch (std::out_of_range& e) {
81219       {
81220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81221       };
81222     } catch (std::exception& e) {
81223       {
81224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81225       };
81226     } catch (Dali::DaliException e) {
81227       {
81228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81229       };
81230     } catch (...) {
81231       {
81232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81233       };
81234     }
81235   }
81236
81237 }
81238
81239
81240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
81241   unsigned int jresult ;
81242   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81243   bool result;
81244
81245   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81246   {
81247     try {
81248       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
81249     } catch (std::out_of_range& e) {
81250       {
81251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81252       };
81253     } catch (std::exception& e) {
81254       {
81255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81256       };
81257     } catch (Dali::DaliException e) {
81258       {
81259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81260       };
81261     } catch (...) {
81262       {
81263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81264       };
81265     }
81266   }
81267
81268   jresult = result;
81269   return jresult;
81270 }
81271
81272
81273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
81274   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81275   bool arg2 ;
81276
81277   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81278   arg2 = jarg2 ? true : false;
81279   {
81280     try {
81281       (arg1)->SetWrapMode(arg2);
81282     } catch (std::out_of_range& e) {
81283       {
81284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81285       };
81286     } catch (std::exception& e) {
81287       {
81288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81289       };
81290     } catch (Dali::DaliException e) {
81291       {
81292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81293       };
81294     } catch (...) {
81295       {
81296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81297       };
81298     }
81299   }
81300
81301 }
81302
81303
81304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
81305   unsigned int jresult ;
81306   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81307   bool result;
81308
81309   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81310   {
81311     try {
81312       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
81313     } catch (std::out_of_range& e) {
81314       {
81315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81316       };
81317     } catch (std::exception& e) {
81318       {
81319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81320       };
81321     } catch (Dali::DaliException e) {
81322       {
81323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81324       };
81325     } catch (...) {
81326       {
81327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81328       };
81329     }
81330   }
81331
81332   jresult = result;
81333   return jresult;
81334 }
81335
81336
81337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
81338   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81339   Dali::Actor arg2 ;
81340   Dali::Actor *argp2 ;
81341
81342   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81343   argp2 = (Dali::Actor *)jarg2;
81344   if (!argp2) {
81345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81346     return ;
81347   }
81348   arg2 = *argp2;
81349   {
81350     try {
81351       (arg1)->SetFocusIndicatorActor(arg2);
81352     } catch (std::out_of_range& e) {
81353       {
81354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81355       };
81356     } catch (std::exception& e) {
81357       {
81358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81359       };
81360     } catch (Dali::DaliException e) {
81361       {
81362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81363       };
81364     } catch (...) {
81365       {
81366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81367       };
81368     }
81369   }
81370
81371 }
81372
81373
81374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
81375   void * jresult ;
81376   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81377   Dali::Actor result;
81378
81379   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81380   {
81381     try {
81382       result = (arg1)->GetFocusIndicatorActor();
81383     } catch (std::out_of_range& e) {
81384       {
81385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81386       };
81387     } catch (std::exception& e) {
81388       {
81389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81390       };
81391     } catch (Dali::DaliException e) {
81392       {
81393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81394       };
81395     } catch (...) {
81396       {
81397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81398       };
81399     }
81400   }
81401
81402   jresult = new Dali::Actor((const Dali::Actor &)result);
81403   return jresult;
81404 }
81405
81406
81407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
81408   void * jresult ;
81409   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81410   Dali::Actor arg2 ;
81411   Dali::Actor *argp2 ;
81412   Dali::Actor result;
81413
81414   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81415   argp2 = (Dali::Actor *)jarg2;
81416   if (!argp2) {
81417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81418     return 0;
81419   }
81420   arg2 = *argp2;
81421   {
81422     try {
81423       result = (arg1)->GetFocusGroup(arg2);
81424     } catch (std::out_of_range& e) {
81425       {
81426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81427       };
81428     } catch (std::exception& e) {
81429       {
81430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81431       };
81432     } catch (Dali::DaliException e) {
81433       {
81434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81435       };
81436     } catch (...) {
81437       {
81438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81439       };
81440     }
81441   }
81442
81443   jresult = new Dali::Actor((const Dali::Actor &)result);
81444   return jresult;
81445 }
81446
81447
81448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
81449   void * jresult ;
81450   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81451   Dali::Vector2 result;
81452
81453   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81454   {
81455     try {
81456       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
81457     } catch (std::out_of_range& e) {
81458       {
81459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81460       };
81461     } catch (std::exception& e) {
81462       {
81463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81464       };
81465     } catch (Dali::DaliException e) {
81466       {
81467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81468       };
81469     } catch (...) {
81470       {
81471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81472       };
81473     }
81474   }
81475
81476   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81477   return jresult;
81478 }
81479
81480
81481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
81482   void * jresult ;
81483   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81484   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
81485
81486   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81487   {
81488     try {
81489       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
81490     } catch (std::out_of_range& e) {
81491       {
81492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81493       };
81494     } catch (std::exception& e) {
81495       {
81496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81497       };
81498     } catch (Dali::DaliException e) {
81499       {
81500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81501       };
81502     } catch (...) {
81503       {
81504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81505       };
81506     }
81507   }
81508
81509   jresult = (void *)result;
81510   return jresult;
81511 }
81512
81513
81514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
81515   void * jresult ;
81516   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81517   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
81518
81519   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81520   {
81521     try {
81522       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
81523     } catch (std::out_of_range& e) {
81524       {
81525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81526       };
81527     } catch (std::exception& e) {
81528       {
81529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81530       };
81531     } catch (Dali::DaliException e) {
81532       {
81533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81534       };
81535     } catch (...) {
81536       {
81537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81538       };
81539     }
81540   }
81541
81542   jresult = (void *)result;
81543   return jresult;
81544 }
81545
81546
81547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
81548   void * jresult ;
81549   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81550   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
81551
81552   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81553   {
81554     try {
81555       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
81556     } catch (std::out_of_range& e) {
81557       {
81558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81559       };
81560     } catch (std::exception& e) {
81561       {
81562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81563       };
81564     } catch (Dali::DaliException e) {
81565       {
81566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81567       };
81568     } catch (...) {
81569       {
81570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81571       };
81572     }
81573   }
81574
81575   jresult = (void *)result;
81576   return jresult;
81577 }
81578
81579
81580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
81581   void * jresult ;
81582   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81583   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81584
81585   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81586   {
81587     try {
81588       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
81589     } catch (std::out_of_range& e) {
81590       {
81591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81592       };
81593     } catch (std::exception& e) {
81594       {
81595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81596       };
81597     } catch (Dali::DaliException e) {
81598       {
81599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81600       };
81601     } catch (...) {
81602       {
81603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81604       };
81605     }
81606   }
81607
81608   jresult = (void *)result;
81609   return jresult;
81610 }
81611
81612
81613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
81614   void * jresult ;
81615   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81616   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81617
81618   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81619   {
81620     try {
81621       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
81622     } catch (std::out_of_range& e) {
81623       {
81624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81625       };
81626     } catch (std::exception& e) {
81627       {
81628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81629       };
81630     } catch (Dali::DaliException e) {
81631       {
81632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81633       };
81634     } catch (...) {
81635       {
81636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81637       };
81638     }
81639   }
81640
81641   jresult = (void *)result;
81642   return jresult;
81643 }
81644
81645
81646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
81647   void * jresult ;
81648   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81649   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81650
81651   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81652   {
81653     try {
81654       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
81655     } catch (std::out_of_range& e) {
81656       {
81657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81658       };
81659     } catch (std::exception& e) {
81660       {
81661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81662       };
81663     } catch (Dali::DaliException e) {
81664       {
81665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81666       };
81667     } catch (...) {
81668       {
81669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81670       };
81671     }
81672   }
81673
81674   jresult = (void *)result;
81675   return jresult;
81676 }
81677
81678
81679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
81680   void * jresult ;
81681   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81682   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81683
81684   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81685   {
81686     try {
81687       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
81688     } catch (std::out_of_range& e) {
81689       {
81690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81691       };
81692     } catch (std::exception& e) {
81693       {
81694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81695       };
81696     } catch (Dali::DaliException e) {
81697       {
81698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81699       };
81700     } catch (...) {
81701       {
81702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81703       };
81704     }
81705   }
81706
81707   jresult = (void *)result;
81708   return jresult;
81709 }
81710
81711
81712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
81713   void * jresult ;
81714   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81715   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81716
81717   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81718   {
81719     try {
81720       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
81721     } catch (std::out_of_range& e) {
81722       {
81723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81724       };
81725     } catch (std::exception& e) {
81726       {
81727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81728       };
81729     } catch (Dali::DaliException e) {
81730       {
81731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81732       };
81733     } catch (...) {
81734       {
81735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81736       };
81737     }
81738   }
81739
81740   jresult = (void *)result;
81741   return jresult;
81742 }
81743
81744
81745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
81746   void * jresult ;
81747   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81748   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81749
81750   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81751   {
81752     try {
81753       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
81754     } catch (std::out_of_range& e) {
81755       {
81756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81757       };
81758     } catch (std::exception& e) {
81759       {
81760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81761       };
81762     } catch (Dali::DaliException e) {
81763       {
81764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81765       };
81766     } catch (...) {
81767       {
81768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81769       };
81770     }
81771   }
81772
81773   jresult = (void *)result;
81774   return jresult;
81775 }
81776
81777
81778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
81779   void * jresult ;
81780   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81781   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81782
81783   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81784   {
81785     try {
81786       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
81787     } catch (std::out_of_range& e) {
81788       {
81789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81790       };
81791     } catch (std::exception& e) {
81792       {
81793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81794       };
81795     } catch (Dali::DaliException e) {
81796       {
81797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81798       };
81799     } catch (...) {
81800       {
81801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81802       };
81803     }
81804   }
81805
81806   jresult = (void *)result;
81807   return jresult;
81808 }
81809
81810
81811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
81812   void * jresult ;
81813   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81814   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81815
81816   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81817   {
81818     try {
81819       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
81820     } catch (std::out_of_range& e) {
81821       {
81822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81823       };
81824     } catch (std::exception& e) {
81825       {
81826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81827       };
81828     } catch (Dali::DaliException e) {
81829       {
81830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81831       };
81832     } catch (...) {
81833       {
81834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81835       };
81836     }
81837   }
81838
81839   jresult = (void *)result;
81840   return jresult;
81841 }
81842
81843
81844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
81845   void * jresult ;
81846   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81847   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81848
81849   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81850   {
81851     try {
81852       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
81853     } catch (std::out_of_range& e) {
81854       {
81855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81856       };
81857     } catch (std::exception& e) {
81858       {
81859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81860       };
81861     } catch (Dali::DaliException e) {
81862       {
81863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81864       };
81865     } catch (...) {
81866       {
81867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81868       };
81869     }
81870   }
81871
81872   jresult = (void *)result;
81873   return jresult;
81874 }
81875
81876
81877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
81878   void * jresult ;
81879   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81880   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81881
81882   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81883   {
81884     try {
81885       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
81886     } catch (std::out_of_range& e) {
81887       {
81888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81889       };
81890     } catch (std::exception& e) {
81891       {
81892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81893       };
81894     } catch (Dali::DaliException e) {
81895       {
81896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81897       };
81898     } catch (...) {
81899       {
81900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81901       };
81902     }
81903   }
81904
81905   jresult = (void *)result;
81906   return jresult;
81907 }
81908
81909
81910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
81911   void * jresult ;
81912   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81913   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81914
81915   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81916   {
81917     try {
81918       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
81919     } catch (std::out_of_range& e) {
81920       {
81921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81922       };
81923     } catch (std::exception& e) {
81924       {
81925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81926       };
81927     } catch (Dali::DaliException e) {
81928       {
81929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81930       };
81931     } catch (...) {
81932       {
81933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81934       };
81935     }
81936   }
81937
81938   jresult = (void *)result;
81939   return jresult;
81940 }
81941
81942
81943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
81944   void * jresult ;
81945   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81946   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81947
81948   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81949   {
81950     try {
81951       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
81952     } catch (std::out_of_range& e) {
81953       {
81954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81955       };
81956     } catch (std::exception& e) {
81957       {
81958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81959       };
81960     } catch (Dali::DaliException e) {
81961       {
81962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81963       };
81964     } catch (...) {
81965       {
81966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81967       };
81968     }
81969   }
81970
81971   jresult = (void *)result;
81972   return jresult;
81973 }
81974
81975
81976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
81977   void * jresult ;
81978   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81979   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81980
81981   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81982   {
81983     try {
81984       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
81985     } catch (std::out_of_range& e) {
81986       {
81987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81988       };
81989     } catch (std::exception& e) {
81990       {
81991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81992       };
81993     } catch (Dali::DaliException e) {
81994       {
81995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81996       };
81997     } catch (...) {
81998       {
81999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82000       };
82001     }
82002   }
82003
82004   jresult = (void *)result;
82005   return jresult;
82006 }
82007
82008
82009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
82010   void * jresult ;
82011   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82012   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82013
82014   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82015   {
82016     try {
82017       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
82018     } catch (std::out_of_range& e) {
82019       {
82020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82021       };
82022     } catch (std::exception& e) {
82023       {
82024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82025       };
82026     } catch (Dali::DaliException e) {
82027       {
82028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82029       };
82030     } catch (...) {
82031       {
82032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82033       };
82034     }
82035   }
82036
82037   jresult = (void *)result;
82038   return jresult;
82039 }
82040
82041
82042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
82043   void * jresult ;
82044   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82045   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82046
82047   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82048   {
82049     try {
82050       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
82051     } catch (std::out_of_range& e) {
82052       {
82053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82054       };
82055     } catch (std::exception& e) {
82056       {
82057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82058       };
82059     } catch (Dali::DaliException e) {
82060       {
82061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82062       };
82063     } catch (...) {
82064       {
82065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82066       };
82067     }
82068   }
82069
82070   jresult = (void *)result;
82071   return jresult;
82072 }
82073
82074
82075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
82076   void * jresult ;
82077   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82078   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82079
82080   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82081   {
82082     try {
82083       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
82084     } catch (std::out_of_range& e) {
82085       {
82086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82087       };
82088     } catch (std::exception& e) {
82089       {
82090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82091       };
82092     } catch (Dali::DaliException e) {
82093       {
82094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82095       };
82096     } catch (...) {
82097       {
82098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82099       };
82100     }
82101   }
82102
82103   jresult = (void *)result;
82104   return jresult;
82105 }
82106
82107
82108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
82109   void * jresult ;
82110   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82111   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82112
82113   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82114   {
82115     try {
82116       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
82117     } catch (std::out_of_range& e) {
82118       {
82119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82120       };
82121     } catch (std::exception& e) {
82122       {
82123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82124       };
82125     } catch (Dali::DaliException e) {
82126       {
82127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82128       };
82129     } catch (...) {
82130       {
82131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82132       };
82133     }
82134   }
82135
82136   jresult = (void *)result;
82137   return jresult;
82138 }
82139
82140
82141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
82142   void * jresult ;
82143   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82144   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82145
82146   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82147   {
82148     try {
82149       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
82150     } catch (std::out_of_range& e) {
82151       {
82152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82153       };
82154     } catch (std::exception& e) {
82155       {
82156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82157       };
82158     } catch (Dali::DaliException e) {
82159       {
82160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82161       };
82162     } catch (...) {
82163       {
82164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82165       };
82166     }
82167   }
82168
82169   jresult = (void *)result;
82170   return jresult;
82171 }
82172
82173
82174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
82175   void * jresult ;
82176   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82177   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82178
82179   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82180   {
82181     try {
82182       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
82183     } catch (std::out_of_range& e) {
82184       {
82185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82186       };
82187     } catch (std::exception& e) {
82188       {
82189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82190       };
82191     } catch (Dali::DaliException e) {
82192       {
82193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82194       };
82195     } catch (...) {
82196       {
82197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82198       };
82199     }
82200   }
82201
82202   jresult = (void *)result;
82203   return jresult;
82204 }
82205
82206
82207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
82208   void * jresult ;
82209   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82210   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82211
82212   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82213   {
82214     try {
82215       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
82216     } catch (std::out_of_range& e) {
82217       {
82218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82219       };
82220     } catch (std::exception& e) {
82221       {
82222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82223       };
82224     } catch (Dali::DaliException e) {
82225       {
82226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82227       };
82228     } catch (...) {
82229       {
82230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82231       };
82232     }
82233   }
82234
82235   jresult = (void *)result;
82236   return jresult;
82237 }
82238
82239
82240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
82241   void * jresult ;
82242   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82243   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82244
82245   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82246   {
82247     try {
82248       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
82249     } catch (std::out_of_range& e) {
82250       {
82251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82252       };
82253     } catch (std::exception& e) {
82254       {
82255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82256       };
82257     } catch (Dali::DaliException e) {
82258       {
82259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82260       };
82261     } catch (...) {
82262       {
82263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82264       };
82265     }
82266   }
82267
82268   jresult = (void *)result;
82269   return jresult;
82270 }
82271
82272
82273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
82274   void * jresult ;
82275   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82276   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82277
82278   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82279   {
82280     try {
82281       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
82282     } catch (std::out_of_range& e) {
82283       {
82284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82285       };
82286     } catch (std::exception& e) {
82287       {
82288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82289       };
82290     } catch (Dali::DaliException e) {
82291       {
82292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82293       };
82294     } catch (...) {
82295       {
82296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82297       };
82298     }
82299   }
82300
82301   jresult = (void *)result;
82302   return jresult;
82303 }
82304
82305
82306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
82307   void * jresult ;
82308   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82309   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82310
82311   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82312   {
82313     try {
82314       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
82315     } catch (std::out_of_range& e) {
82316       {
82317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82318       };
82319     } catch (std::exception& e) {
82320       {
82321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82322       };
82323     } catch (Dali::DaliException e) {
82324       {
82325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82326       };
82327     } catch (...) {
82328       {
82329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82330       };
82331     }
82332   }
82333
82334   jresult = (void *)result;
82335   return jresult;
82336 }
82337
82338
82339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
82340   void * jresult ;
82341   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82342   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82343
82344   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82345   {
82346     try {
82347       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
82348     } catch (std::out_of_range& e) {
82349       {
82350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82351       };
82352     } catch (std::exception& e) {
82353       {
82354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82355       };
82356     } catch (Dali::DaliException e) {
82357       {
82358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82359       };
82360     } catch (...) {
82361       {
82362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82363       };
82364     }
82365   }
82366
82367   jresult = (void *)result;
82368   return jresult;
82369 }
82370
82371
82372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
82373   void * jresult ;
82374   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82375   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82376
82377   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82378   {
82379     try {
82380       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
82381     } catch (std::out_of_range& e) {
82382       {
82383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82384       };
82385     } catch (std::exception& e) {
82386       {
82387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82388       };
82389     } catch (Dali::DaliException e) {
82390       {
82391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82392       };
82393     } catch (...) {
82394       {
82395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82396       };
82397     }
82398   }
82399
82400   jresult = (void *)result;
82401   return jresult;
82402 }
82403
82404
82405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
82406   void * jresult ;
82407   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82408   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82409
82410   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82411   {
82412     try {
82413       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
82414     } catch (std::out_of_range& e) {
82415       {
82416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82417       };
82418     } catch (std::exception& e) {
82419       {
82420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82421       };
82422     } catch (Dali::DaliException e) {
82423       {
82424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82425       };
82426     } catch (...) {
82427       {
82428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82429       };
82430     }
82431   }
82432
82433   jresult = (void *)result;
82434   return jresult;
82435 }
82436
82437
82438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
82439   void * jresult ;
82440   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82441   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
82442
82443   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82444   {
82445     try {
82446       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
82447     } catch (std::out_of_range& e) {
82448       {
82449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82450       };
82451     } catch (std::exception& e) {
82452       {
82453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82454       };
82455     } catch (Dali::DaliException e) {
82456       {
82457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82458       };
82459     } catch (...) {
82460       {
82461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82462       };
82463     }
82464   }
82465
82466   jresult = (void *)result;
82467   return jresult;
82468 }
82469
82470
82471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
82472   void * jresult ;
82473   Dali::Toolkit::StyleManager *result = 0 ;
82474
82475   {
82476     try {
82477       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
82478     } catch (std::out_of_range& e) {
82479       {
82480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82481       };
82482     } catch (std::exception& e) {
82483       {
82484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82485       };
82486     } catch (Dali::DaliException e) {
82487       {
82488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82489       };
82490     } catch (...) {
82491       {
82492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82493       };
82494     }
82495   }
82496
82497   jresult = (void *)result;
82498   return jresult;
82499 }
82500
82501
82502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
82503   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
82504
82505   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
82506   {
82507     try {
82508       delete arg1;
82509     } catch (std::out_of_range& e) {
82510       {
82511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82512       };
82513     } catch (std::exception& e) {
82514       {
82515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82516       };
82517     } catch (Dali::DaliException e) {
82518       {
82519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82520       };
82521     } catch (...) {
82522       {
82523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82524       };
82525     }
82526   }
82527
82528 }
82529
82530
82531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
82532   void * jresult ;
82533   Dali::Toolkit::StyleManager result;
82534
82535   {
82536     try {
82537       result = Dali::Toolkit::StyleManager::Get();
82538     } catch (std::out_of_range& e) {
82539       {
82540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82541       };
82542     } catch (std::exception& e) {
82543       {
82544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82545       };
82546     } catch (Dali::DaliException e) {
82547       {
82548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82549       };
82550     } catch (...) {
82551       {
82552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82553       };
82554     }
82555   }
82556
82557   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
82558   return jresult;
82559 }
82560
82561
82562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
82563   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
82564   std::string *arg2 = 0 ;
82565
82566   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
82567   if (!jarg2) {
82568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82569     return ;
82570   }
82571   std::string arg2_str(jarg2);
82572   arg2 = &arg2_str;
82573   {
82574     try {
82575       (arg1)->ApplyTheme((std::string const &)*arg2);
82576     } catch (std::out_of_range& e) {
82577       {
82578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82579       };
82580     } catch (std::exception& e) {
82581       {
82582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82583       };
82584     } catch (Dali::DaliException e) {
82585       {
82586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82587       };
82588     } catch (...) {
82589       {
82590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82591       };
82592     }
82593   }
82594
82595
82596   //argout typemap for const std::string&
82597
82598 }
82599
82600
82601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
82602   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
82603
82604   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
82605   {
82606     try {
82607       (arg1)->ApplyDefaultTheme();
82608     } catch (std::out_of_range& e) {
82609       {
82610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82611       };
82612     } catch (std::exception& e) {
82613       {
82614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82615       };
82616     } catch (Dali::DaliException e) {
82617       {
82618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82619       };
82620     } catch (...) {
82621       {
82622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82623       };
82624     }
82625   }
82626
82627 }
82628
82629
82630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
82631   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
82632   std::string *arg2 = 0 ;
82633   Dali::Property::Value *arg3 = 0 ;
82634
82635   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
82636   if (!jarg2) {
82637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82638     return ;
82639   }
82640   std::string arg2_str(jarg2);
82641   arg2 = &arg2_str;
82642   arg3 = (Dali::Property::Value *)jarg3;
82643   if (!arg3) {
82644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
82645     return ;
82646   }
82647   {
82648     try {
82649       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
82650     } catch (std::out_of_range& e) {
82651       {
82652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82653       };
82654     } catch (std::exception& e) {
82655       {
82656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82657       };
82658     } catch (Dali::DaliException e) {
82659       {
82660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82661       };
82662     } catch (...) {
82663       {
82664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82665       };
82666     }
82667   }
82668
82669
82670   //argout typemap for const std::string&
82671
82672 }
82673
82674
82675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
82676   unsigned int jresult ;
82677   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
82678   std::string *arg2 = 0 ;
82679   Dali::Property::Value *arg3 = 0 ;
82680   bool result;
82681
82682   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
82683   if (!jarg2) {
82684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82685     return 0;
82686   }
82687   std::string arg2_str(jarg2);
82688   arg2 = &arg2_str;
82689   arg3 = (Dali::Property::Value *)jarg3;
82690   if (!arg3) {
82691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
82692     return 0;
82693   }
82694   {
82695     try {
82696       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
82697     } catch (std::out_of_range& e) {
82698       {
82699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82700       };
82701     } catch (std::exception& e) {
82702       {
82703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82704       };
82705     } catch (Dali::DaliException e) {
82706       {
82707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82708       };
82709     } catch (...) {
82710       {
82711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82712       };
82713     }
82714   }
82715
82716   jresult = result;
82717
82718   //argout typemap for const std::string&
82719
82720   return jresult;
82721 }
82722
82723
82724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
82725   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
82726   Dali::Toolkit::Control arg2 ;
82727   std::string *arg3 = 0 ;
82728   std::string *arg4 = 0 ;
82729   Dali::Toolkit::Control *argp2 ;
82730
82731   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
82732   argp2 = (Dali::Toolkit::Control *)jarg2;
82733   if (!argp2) {
82734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
82735     return ;
82736   }
82737   arg2 = *argp2;
82738   if (!jarg3) {
82739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82740     return ;
82741   }
82742   std::string arg3_str(jarg3);
82743   arg3 = &arg3_str;
82744   if (!jarg4) {
82745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82746     return ;
82747   }
82748   std::string arg4_str(jarg4);
82749   arg4 = &arg4_str;
82750   {
82751     try {
82752       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
82753     } catch (std::out_of_range& e) {
82754       {
82755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82756       };
82757     } catch (std::exception& e) {
82758       {
82759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82760       };
82761     } catch (Dali::DaliException e) {
82762       {
82763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82764       };
82765     } catch (...) {
82766       {
82767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82768       };
82769     }
82770   }
82771
82772
82773   //argout typemap for const std::string&
82774
82775
82776   //argout typemap for const std::string&
82777
82778 }
82779
82780
82781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
82782   void * jresult ;
82783   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
82784   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
82785
82786   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
82787   {
82788     try {
82789       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
82790     } catch (std::out_of_range& e) {
82791       {
82792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82793       };
82794     } catch (std::exception& e) {
82795       {
82796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82797       };
82798     } catch (Dali::DaliException e) {
82799       {
82800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82801       };
82802     } catch (...) {
82803       {
82804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82805       };
82806     }
82807   }
82808
82809   jresult = (void *)result;
82810   return jresult;
82811 }
82812
82813
82814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
82815   int jresult ;
82816   int result;
82817
82818   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
82819   jresult = (int)result;
82820   return jresult;
82821 }
82822
82823
82824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
82825   int jresult ;
82826   int result;
82827
82828   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
82829   jresult = (int)result;
82830   return jresult;
82831 }
82832
82833
82834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
82835   int jresult ;
82836   int result;
82837
82838   result = (int)Dali::Toolkit::Slider::Property::VALUE;
82839   jresult = (int)result;
82840   return jresult;
82841 }
82842
82843
82844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
82845   int jresult ;
82846   int result;
82847
82848   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
82849   jresult = (int)result;
82850   return jresult;
82851 }
82852
82853
82854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
82855   int jresult ;
82856   int result;
82857
82858   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
82859   jresult = (int)result;
82860   return jresult;
82861 }
82862
82863
82864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
82865   int jresult ;
82866   int result;
82867
82868   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
82869   jresult = (int)result;
82870   return jresult;
82871 }
82872
82873
82874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
82875   int jresult ;
82876   int result;
82877
82878   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
82879   jresult = (int)result;
82880   return jresult;
82881 }
82882
82883
82884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
82885   int jresult ;
82886   int result;
82887
82888   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
82889   jresult = (int)result;
82890   return jresult;
82891 }
82892
82893
82894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
82895   int jresult ;
82896   int result;
82897
82898   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
82899   jresult = (int)result;
82900   return jresult;
82901 }
82902
82903
82904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
82905   int jresult ;
82906   int result;
82907
82908   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
82909   jresult = (int)result;
82910   return jresult;
82911 }
82912
82913
82914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
82915   int jresult ;
82916   int result;
82917
82918   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
82919   jresult = (int)result;
82920   return jresult;
82921 }
82922
82923
82924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
82925   int jresult ;
82926   int result;
82927
82928   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
82929   jresult = (int)result;
82930   return jresult;
82931 }
82932
82933
82934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
82935   int jresult ;
82936   int result;
82937
82938   result = (int)Dali::Toolkit::Slider::Property::MARKS;
82939   jresult = (int)result;
82940   return jresult;
82941 }
82942
82943
82944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
82945   int jresult ;
82946   int result;
82947
82948   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
82949   jresult = (int)result;
82950   return jresult;
82951 }
82952
82953
82954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
82955   int jresult ;
82956   int result;
82957
82958   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
82959   jresult = (int)result;
82960   return jresult;
82961 }
82962
82963
82964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
82965   void * jresult ;
82966   Dali::Toolkit::Slider::Property *result = 0 ;
82967
82968   {
82969     try {
82970       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
82971     } catch (std::out_of_range& e) {
82972       {
82973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82974       };
82975     } catch (std::exception& e) {
82976       {
82977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82978       };
82979     } catch (Dali::DaliException e) {
82980       {
82981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82982       };
82983     } catch (...) {
82984       {
82985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82986       };
82987     }
82988   }
82989
82990   jresult = (void *)result;
82991   return jresult;
82992 }
82993
82994
82995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
82996   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
82997
82998   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
82999   {
83000     try {
83001       delete arg1;
83002     } catch (std::out_of_range& e) {
83003       {
83004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83005       };
83006     } catch (std::exception& e) {
83007       {
83008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83009       };
83010     } catch (Dali::DaliException e) {
83011       {
83012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83013       };
83014     } catch (...) {
83015       {
83016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83017       };
83018     }
83019   }
83020
83021 }
83022
83023
83024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
83025   void * jresult ;
83026   Dali::Toolkit::Slider result;
83027
83028   {
83029     try {
83030       result = Dali::Toolkit::Slider::New();
83031     } catch (std::out_of_range& e) {
83032       {
83033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83034       };
83035     } catch (std::exception& e) {
83036       {
83037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83038       };
83039     } catch (Dali::DaliException e) {
83040       {
83041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83042       };
83043     } catch (...) {
83044       {
83045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83046       };
83047     }
83048   }
83049
83050   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
83051   return jresult;
83052 }
83053
83054
83055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
83056   void * jresult ;
83057   Dali::Toolkit::Slider *result = 0 ;
83058
83059   {
83060     try {
83061       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
83062     } catch (std::out_of_range& e) {
83063       {
83064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83065       };
83066     } catch (std::exception& e) {
83067       {
83068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83069       };
83070     } catch (Dali::DaliException e) {
83071       {
83072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83073       };
83074     } catch (...) {
83075       {
83076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83077       };
83078     }
83079   }
83080
83081   jresult = (void *)result;
83082   return jresult;
83083 }
83084
83085
83086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
83087   void * jresult ;
83088   Dali::Toolkit::Slider *arg1 = 0 ;
83089   Dali::Toolkit::Slider *result = 0 ;
83090
83091   arg1 = (Dali::Toolkit::Slider *)jarg1;
83092   if (!arg1) {
83093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
83094     return 0;
83095   }
83096   {
83097     try {
83098       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
83099     } catch (std::out_of_range& e) {
83100       {
83101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83102       };
83103     } catch (std::exception& e) {
83104       {
83105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83106       };
83107     } catch (Dali::DaliException e) {
83108       {
83109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83110       };
83111     } catch (...) {
83112       {
83113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83114       };
83115     }
83116   }
83117
83118   jresult = (void *)result;
83119   return jresult;
83120 }
83121
83122
83123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
83124   void * jresult ;
83125   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
83126   Dali::Toolkit::Slider *arg2 = 0 ;
83127   Dali::Toolkit::Slider *result = 0 ;
83128
83129   arg1 = (Dali::Toolkit::Slider *)jarg1;
83130   arg2 = (Dali::Toolkit::Slider *)jarg2;
83131   if (!arg2) {
83132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
83133     return 0;
83134   }
83135   {
83136     try {
83137       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
83138     } catch (std::out_of_range& e) {
83139       {
83140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83141       };
83142     } catch (std::exception& e) {
83143       {
83144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83145       };
83146     } catch (Dali::DaliException e) {
83147       {
83148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83149       };
83150     } catch (...) {
83151       {
83152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83153       };
83154     }
83155   }
83156
83157   jresult = (void *)result;
83158   return jresult;
83159 }
83160
83161
83162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
83163   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
83164
83165   arg1 = (Dali::Toolkit::Slider *)jarg1;
83166   {
83167     try {
83168       delete arg1;
83169     } catch (std::out_of_range& e) {
83170       {
83171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83172       };
83173     } catch (std::exception& e) {
83174       {
83175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83176       };
83177     } catch (Dali::DaliException e) {
83178       {
83179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83180       };
83181     } catch (...) {
83182       {
83183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83184       };
83185     }
83186   }
83187
83188 }
83189
83190
83191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
83192   void * jresult ;
83193   Dali::BaseHandle arg1 ;
83194   Dali::BaseHandle *argp1 ;
83195   Dali::Toolkit::Slider result;
83196
83197   argp1 = (Dali::BaseHandle *)jarg1;
83198   if (!argp1) {
83199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83200     return 0;
83201   }
83202   arg1 = *argp1;
83203   {
83204     try {
83205       result = Dali::Toolkit::Slider::DownCast(arg1);
83206     } catch (std::out_of_range& e) {
83207       {
83208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83209       };
83210     } catch (std::exception& e) {
83211       {
83212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83213       };
83214     } catch (Dali::DaliException e) {
83215       {
83216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83217       };
83218     } catch (...) {
83219       {
83220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83221       };
83222     }
83223   }
83224
83225   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
83226   return jresult;
83227 }
83228
83229
83230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
83231   void * jresult ;
83232   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
83233   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
83234
83235   arg1 = (Dali::Toolkit::Slider *)jarg1;
83236   {
83237     try {
83238       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83239     } catch (std::out_of_range& e) {
83240       {
83241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83242       };
83243     } catch (std::exception& e) {
83244       {
83245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83246       };
83247     } catch (Dali::DaliException e) {
83248       {
83249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83250       };
83251     } catch (...) {
83252       {
83253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83254       };
83255     }
83256   }
83257
83258   jresult = (void *)result;
83259   return jresult;
83260 }
83261
83262
83263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
83264   void * jresult ;
83265   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
83266   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
83267
83268   arg1 = (Dali::Toolkit::Slider *)jarg1;
83269   {
83270     try {
83271       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
83272     } catch (std::out_of_range& e) {
83273       {
83274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83275       };
83276     } catch (std::exception& e) {
83277       {
83278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83279       };
83280     } catch (Dali::DaliException e) {
83281       {
83282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83283       };
83284     } catch (...) {
83285       {
83286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83287       };
83288     }
83289   }
83290
83291   jresult = (void *)result;
83292   return jresult;
83293 }
83294
83295
83296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
83297   void * jresult ;
83298   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
83299   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
83300
83301   arg1 = (Dali::Toolkit::Slider *)jarg1;
83302   {
83303     try {
83304       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
83305     } catch (std::out_of_range& e) {
83306       {
83307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83308       };
83309     } catch (std::exception& e) {
83310       {
83311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83312       };
83313     } catch (Dali::DaliException e) {
83314       {
83315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83316       };
83317     } catch (...) {
83318       {
83319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83320       };
83321     }
83322   }
83323
83324   jresult = (void *)result;
83325   return jresult;
83326 }
83327
83328
83329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
83330   int jresult ;
83331   int result;
83332
83333   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
83334   jresult = (int)result;
83335   return jresult;
83336 }
83337
83338
83339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
83340   int jresult ;
83341   int result;
83342
83343   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
83344   jresult = (int)result;
83345   return jresult;
83346 }
83347
83348
83349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
83350   int jresult ;
83351   int result;
83352
83353   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
83354   jresult = (int)result;
83355   return jresult;
83356 }
83357
83358
83359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
83360   int jresult ;
83361   int result;
83362
83363   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
83364   jresult = (int)result;
83365   return jresult;
83366 }
83367
83368
83369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
83370   int result;
83371
83372   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
83373
83374   return result;
83375 }
83376
83377
83378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
83379   void * jresult ;
83380   Dali::Toolkit::VideoView::Property *result = 0 ;
83381
83382   {
83383     try {
83384       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
83385     } catch (std::out_of_range& e) {
83386       {
83387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83388       };
83389     } catch (std::exception& e) {
83390       {
83391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83392       };
83393     } catch (Dali::DaliException e) {
83394       {
83395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83396       };
83397     } catch (...) {
83398       {
83399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83400       };
83401     }
83402   }
83403
83404   jresult = (void *)result;
83405   return jresult;
83406 }
83407
83408
83409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
83410   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
83411
83412   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
83413   {
83414     try {
83415       delete arg1;
83416     } catch (std::out_of_range& e) {
83417       {
83418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83419       };
83420     } catch (std::exception& e) {
83421       {
83422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83423       };
83424     } catch (Dali::DaliException e) {
83425       {
83426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83427       };
83428     } catch (...) {
83429       {
83430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83431       };
83432     }
83433   }
83434
83435 }
83436
83437
83438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
83439   void * jresult ;
83440   Dali::Toolkit::VideoView result;
83441
83442   {
83443     try {
83444       result = Dali::Toolkit::VideoView::New();
83445     } catch (std::out_of_range& e) {
83446       {
83447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83448       };
83449     } catch (std::exception& e) {
83450       {
83451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83452       };
83453     } catch (Dali::DaliException e) {
83454       {
83455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83456       };
83457     } catch (...) {
83458       {
83459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83460       };
83461     }
83462   }
83463
83464   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
83465   return jresult;
83466 }
83467
83468
83469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
83470   void * jresult ;
83471   std::string *arg1 = 0 ;
83472   Dali::Toolkit::VideoView result;
83473
83474   if (!jarg1) {
83475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83476     return 0;
83477   }
83478   std::string arg1_str(jarg1);
83479   arg1 = &arg1_str;
83480   {
83481     try {
83482       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
83483     } catch (std::out_of_range& e) {
83484       {
83485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83486       };
83487     } catch (std::exception& e) {
83488       {
83489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83490       };
83491     } catch (Dali::DaliException e) {
83492       {
83493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83494       };
83495     } catch (...) {
83496       {
83497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83498       };
83499     }
83500   }
83501
83502   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
83503
83504   //argout typemap for const std::string&
83505
83506   return jresult;
83507 }
83508
83509
83510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
83511   void * jresult ;
83512   Dali::Toolkit::VideoView result;
83513   {
83514     try {
83515       result = Dali::Toolkit::VideoView::New(swCodec);
83516     } catch (std::out_of_range& e) {
83517       {
83518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83519       };
83520     } catch (std::exception& e) {
83521       {
83522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83523       };
83524     } catch (Dali::DaliException e) {
83525       {
83526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83527       };
83528     } catch (...) {
83529       {
83530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83531       };
83532     }
83533   }
83534
83535   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
83536
83537   //argout typemap for const std::string&
83538
83539   return jresult;
83540 }
83541
83542
83543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
83544   void * jresult ;
83545   std::string *arg1 = 0 ;
83546   Dali::Toolkit::VideoView result;
83547
83548   if (!jarg1) {
83549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83550     return 0;
83551   }
83552   std::string arg1_str(jarg1);
83553   arg1 = &arg1_str;
83554   {
83555     try {
83556       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
83557     } catch (std::out_of_range& e) {
83558       {
83559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83560       };
83561     } catch (std::exception& e) {
83562       {
83563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83564       };
83565     } catch (Dali::DaliException e) {
83566       {
83567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83568       };
83569     } catch (...) {
83570       {
83571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83572       };
83573     }
83574   }
83575
83576   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
83577
83578   //argout typemap for const std::string&
83579
83580   return jresult;
83581 }
83582
83583
83584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
83585   void * jresult ;
83586   Dali::Toolkit::VideoView *result = 0 ;
83587
83588   {
83589     try {
83590       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
83591     } catch (std::out_of_range& e) {
83592       {
83593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83594       };
83595     } catch (std::exception& e) {
83596       {
83597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83598       };
83599     } catch (Dali::DaliException e) {
83600       {
83601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83602       };
83603     } catch (...) {
83604       {
83605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83606       };
83607     }
83608   }
83609
83610   jresult = (void *)result;
83611   return jresult;
83612 }
83613
83614
83615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
83616   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
83617
83618   arg1 = (Dali::Toolkit::VideoView *)jarg1;
83619   {
83620     try {
83621       delete arg1;
83622     } catch (std::out_of_range& e) {
83623       {
83624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83625       };
83626     } catch (std::exception& e) {
83627       {
83628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83629       };
83630     } catch (Dali::DaliException e) {
83631       {
83632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83633       };
83634     } catch (...) {
83635       {
83636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83637       };
83638     }
83639   }
83640
83641 }
83642
83643
83644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
83645   void * jresult ;
83646   Dali::Toolkit::VideoView *arg1 = 0 ;
83647   Dali::Toolkit::VideoView *result = 0 ;
83648
83649   arg1 = (Dali::Toolkit::VideoView *)jarg1;
83650   if (!arg1) {
83651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
83652     return 0;
83653   }
83654   {
83655     try {
83656       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
83657     } catch (std::out_of_range& e) {
83658       {
83659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83660       };
83661     } catch (std::exception& e) {
83662       {
83663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83664       };
83665     } catch (Dali::DaliException e) {
83666       {
83667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83668       };
83669     } catch (...) {
83670       {
83671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83672       };
83673     }
83674   }
83675
83676   jresult = (void *)result;
83677   return jresult;
83678 }
83679
83680
83681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
83682   void * jresult ;
83683   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
83684   Dali::Toolkit::VideoView *arg2 = 0 ;
83685   Dali::Toolkit::VideoView *result = 0 ;
83686
83687   arg1 = (Dali::Toolkit::VideoView *)jarg1;
83688   arg2 = (Dali::Toolkit::VideoView *)jarg2;
83689   if (!arg2) {
83690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
83691     return 0;
83692   }
83693   {
83694     try {
83695       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
83696     } catch (std::out_of_range& e) {
83697       {
83698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83699       };
83700     } catch (std::exception& e) {
83701       {
83702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83703       };
83704     } catch (Dali::DaliException e) {
83705       {
83706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83707       };
83708     } catch (...) {
83709       {
83710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83711       };
83712     }
83713   }
83714
83715   jresult = (void *)result;
83716   return jresult;
83717 }
83718
83719
83720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
83721   void * jresult ;
83722   Dali::BaseHandle arg1 ;
83723   Dali::BaseHandle *argp1 ;
83724   Dali::Toolkit::VideoView result;
83725
83726   argp1 = (Dali::BaseHandle *)jarg1;
83727   if (!argp1) {
83728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83729     return 0;
83730   }
83731   arg1 = *argp1;
83732   {
83733     try {
83734       result = Dali::Toolkit::VideoView::DownCast(arg1);
83735     } catch (std::out_of_range& e) {
83736       {
83737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83738       };
83739     } catch (std::exception& e) {
83740       {
83741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83742       };
83743     } catch (Dali::DaliException e) {
83744       {
83745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83746       };
83747     } catch (...) {
83748       {
83749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83750       };
83751     }
83752   }
83753
83754   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
83755   return jresult;
83756 }
83757
83758
83759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
83760   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
83761
83762   arg1 = (Dali::Toolkit::VideoView *)jarg1;
83763   {
83764     try {
83765       (arg1)->Play();
83766     } catch (std::out_of_range& e) {
83767       {
83768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83769       };
83770     } catch (std::exception& e) {
83771       {
83772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83773       };
83774     } catch (Dali::DaliException e) {
83775       {
83776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83777       };
83778     } catch (...) {
83779       {
83780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83781       };
83782     }
83783   }
83784
83785 }
83786
83787
83788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
83789   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
83790
83791   arg1 = (Dali::Toolkit::VideoView *)jarg1;
83792   {
83793     try {
83794       (arg1)->Pause();
83795     } catch (std::out_of_range& e) {
83796       {
83797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83798       };
83799     } catch (std::exception& e) {
83800       {
83801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83802       };
83803     } catch (Dali::DaliException e) {
83804       {
83805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83806       };
83807     } catch (...) {
83808       {
83809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83810       };
83811     }
83812   }
83813
83814 }
83815
83816
83817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
83818   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
83819
83820   arg1 = (Dali::Toolkit::VideoView *)jarg1;
83821   {
83822     try {
83823       (arg1)->Stop();
83824     } catch (std::out_of_range& e) {
83825       {
83826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83827       };
83828     } catch (std::exception& e) {
83829       {
83830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83831       };
83832     } catch (Dali::DaliException e) {
83833       {
83834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83835       };
83836     } catch (...) {
83837       {
83838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83839       };
83840     }
83841   }
83842
83843 }
83844
83845
83846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
83847   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
83848   int arg2 ;
83849
83850   arg1 = (Dali::Toolkit::VideoView *)jarg1;
83851   arg2 = (int)jarg2;
83852   {
83853     try {
83854       (arg1)->Forward(arg2);
83855     } catch (std::out_of_range& e) {
83856       {
83857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83858       };
83859     } catch (std::exception& e) {
83860       {
83861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83862       };
83863     } catch (Dali::DaliException e) {
83864       {
83865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83866       };
83867     } catch (...) {
83868       {
83869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83870       };
83871     }
83872   }
83873
83874 }
83875
83876
83877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
83878   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
83879   int arg2 ;
83880
83881   arg1 = (Dali::Toolkit::VideoView *)jarg1;
83882   arg2 = (int)jarg2;
83883   {
83884     try {
83885       (arg1)->Backward(arg2);
83886     } catch (std::out_of_range& e) {
83887       {
83888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83889       };
83890     } catch (std::exception& e) {
83891       {
83892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83893       };
83894     } catch (Dali::DaliException e) {
83895       {
83896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83897       };
83898     } catch (...) {
83899       {
83900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83901       };
83902     }
83903   }
83904
83905 }
83906
83907
83908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
83909   void * jresult ;
83910   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
83911   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
83912
83913   arg1 = (Dali::Toolkit::VideoView *)jarg1;
83914   {
83915     try {
83916       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
83917     } catch (std::out_of_range& e) {
83918       {
83919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83920       };
83921     } catch (std::exception& e) {
83922       {
83923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83924       };
83925     } catch (Dali::DaliException e) {
83926       {
83927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83928       };
83929     } catch (...) {
83930       {
83931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83932       };
83933     }
83934   }
83935
83936   jresult = (void *)result;
83937   return jresult;
83938 }
83939
83940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
83941 {
83942   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
83943   if( arg1 == nullptr )
83944   {
83945     DALI_LOG_ERROR("VideoView is nullptr!");
83946     return nullptr;
83947   }
83948   void * ret = nullptr;
83949   {
83950     try{
83951
83952       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
83953       ret = Dali::AnyCast< void * >( result );
83954
83955     } catch (std::out_of_range& e) {
83956       {
83957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83958       };
83959     } catch (std::exception& e) {
83960       {
83961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83962       };
83963     } catch (Dali::DaliException e) {
83964       {
83965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83966       };
83967     } catch (...) {
83968       {
83969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83970       };
83971     }
83972   }
83973   return ret;
83974 }
83975
83976
83977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
83978   int jresult ;
83979   int result;
83980
83981   result = (int)Dali::Toolkit::Popup::Property::TITLE;
83982   jresult = (int)result;
83983   return jresult;
83984 }
83985
83986
83987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
83988   int jresult ;
83989   int result;
83990
83991   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
83992   jresult = (int)result;
83993   return jresult;
83994 }
83995
83996
83997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
83998   int jresult ;
83999   int result;
84000
84001   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
84002   jresult = (int)result;
84003   return jresult;
84004 }
84005
84006
84007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
84008   int jresult ;
84009   int result;
84010
84011   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
84012   jresult = (int)result;
84013   return jresult;
84014 }
84015
84016
84017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
84018   int jresult ;
84019   int result;
84020
84021   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
84022   jresult = (int)result;
84023   return jresult;
84024 }
84025
84026
84027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
84028   int jresult ;
84029   int result;
84030
84031   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
84032   jresult = (int)result;
84033   return jresult;
84034 }
84035
84036
84037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
84038   int jresult ;
84039   int result;
84040
84041   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
84042   jresult = (int)result;
84043   return jresult;
84044 }
84045
84046
84047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
84048   int jresult ;
84049   int result;
84050
84051   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
84052   jresult = (int)result;
84053   return jresult;
84054 }
84055
84056
84057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
84058   int jresult ;
84059   int result;
84060
84061   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
84062   jresult = (int)result;
84063   return jresult;
84064 }
84065
84066
84067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
84068   int jresult ;
84069   int result;
84070
84071   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
84072   jresult = (int)result;
84073   return jresult;
84074 }
84075
84076
84077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
84078   int jresult ;
84079   int result;
84080
84081   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
84082   jresult = (int)result;
84083   return jresult;
84084 }
84085
84086
84087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
84088   int jresult ;
84089   int result;
84090
84091   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
84092   jresult = (int)result;
84093   return jresult;
84094 }
84095
84096
84097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
84098   int jresult ;
84099   int result;
84100
84101   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
84102   jresult = (int)result;
84103   return jresult;
84104 }
84105
84106
84107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
84108   int jresult ;
84109   int result;
84110
84111   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
84112   jresult = (int)result;
84113   return jresult;
84114 }
84115
84116
84117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
84118   int jresult ;
84119   int result;
84120
84121   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
84122   jresult = (int)result;
84123   return jresult;
84124 }
84125
84126
84127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
84128   int jresult ;
84129   int result;
84130
84131   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
84132   jresult = (int)result;
84133   return jresult;
84134 }
84135
84136
84137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
84138   int jresult ;
84139   int result;
84140
84141   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
84142   jresult = (int)result;
84143   return jresult;
84144 }
84145
84146
84147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
84148   int jresult ;
84149   int result;
84150
84151   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
84152   jresult = (int)result;
84153   return jresult;
84154 }
84155
84156
84157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
84158   int jresult ;
84159   int result;
84160
84161   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
84162   jresult = (int)result;
84163   return jresult;
84164 }
84165
84166
84167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
84168   int jresult ;
84169   int result;
84170
84171   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
84172   jresult = (int)result;
84173   return jresult;
84174 }
84175
84176
84177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
84178   int jresult ;
84179   int result;
84180
84181   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
84182   jresult = (int)result;
84183   return jresult;
84184 }
84185
84186
84187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
84188   void * jresult ;
84189   Dali::Toolkit::Popup::Property *result = 0 ;
84190
84191   {
84192     try {
84193       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
84194     } catch (std::out_of_range& e) {
84195       {
84196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84197       };
84198     } catch (std::exception& e) {
84199       {
84200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84201       };
84202     } catch (Dali::DaliException e) {
84203       {
84204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84205       };
84206     } catch (...) {
84207       {
84208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84209       };
84210     }
84211   }
84212
84213   jresult = (void *)result;
84214   return jresult;
84215 }
84216
84217
84218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
84219   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
84220
84221   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
84222   {
84223     try {
84224       delete arg1;
84225     } catch (std::out_of_range& e) {
84226       {
84227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84228       };
84229     } catch (std::exception& e) {
84230       {
84231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84232       };
84233     } catch (Dali::DaliException e) {
84234       {
84235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84236       };
84237     } catch (...) {
84238       {
84239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84240       };
84241     }
84242   }
84243
84244 }
84245
84246
84247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
84248   void * jresult ;
84249   Dali::Toolkit::Popup *result = 0 ;
84250
84251   {
84252     try {
84253       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
84254     } catch (std::out_of_range& e) {
84255       {
84256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84257       };
84258     } catch (std::exception& e) {
84259       {
84260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84261       };
84262     } catch (Dali::DaliException e) {
84263       {
84264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84265       };
84266     } catch (...) {
84267       {
84268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84269       };
84270     }
84271   }
84272
84273   jresult = (void *)result;
84274   return jresult;
84275 }
84276
84277
84278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
84279   void * jresult ;
84280   Dali::Toolkit::Popup result;
84281
84282   {
84283     try {
84284       result = Dali::Toolkit::Popup::New();
84285     } catch (std::out_of_range& e) {
84286       {
84287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84288       };
84289     } catch (std::exception& e) {
84290       {
84291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84292       };
84293     } catch (Dali::DaliException e) {
84294       {
84295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84296       };
84297     } catch (...) {
84298       {
84299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84300       };
84301     }
84302   }
84303
84304   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
84305   return jresult;
84306 }
84307
84308
84309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
84310   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
84311
84312   arg1 = (Dali::Toolkit::Popup *)jarg1;
84313   {
84314     try {
84315       delete arg1;
84316     } catch (std::out_of_range& e) {
84317       {
84318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84319       };
84320     } catch (std::exception& e) {
84321       {
84322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84323       };
84324     } catch (Dali::DaliException e) {
84325       {
84326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84327       };
84328     } catch (...) {
84329       {
84330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84331       };
84332     }
84333   }
84334
84335 }
84336
84337
84338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
84339   void * jresult ;
84340   Dali::Toolkit::Popup *arg1 = 0 ;
84341   Dali::Toolkit::Popup *result = 0 ;
84342
84343   arg1 = (Dali::Toolkit::Popup *)jarg1;
84344   if (!arg1) {
84345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
84346     return 0;
84347   }
84348   {
84349     try {
84350       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
84351     } catch (std::out_of_range& e) {
84352       {
84353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84354       };
84355     } catch (std::exception& e) {
84356       {
84357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84358       };
84359     } catch (Dali::DaliException e) {
84360       {
84361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84362       };
84363     } catch (...) {
84364       {
84365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84366       };
84367     }
84368   }
84369
84370   jresult = (void *)result;
84371   return jresult;
84372 }
84373
84374
84375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
84376   void * jresult ;
84377   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
84378   Dali::Toolkit::Popup *arg2 = 0 ;
84379   Dali::Toolkit::Popup *result = 0 ;
84380
84381   arg1 = (Dali::Toolkit::Popup *)jarg1;
84382   arg2 = (Dali::Toolkit::Popup *)jarg2;
84383   if (!arg2) {
84384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
84385     return 0;
84386   }
84387   {
84388     try {
84389       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
84390     } catch (std::out_of_range& e) {
84391       {
84392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84393       };
84394     } catch (std::exception& e) {
84395       {
84396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84397       };
84398     } catch (Dali::DaliException e) {
84399       {
84400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84401       };
84402     } catch (...) {
84403       {
84404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84405       };
84406     }
84407   }
84408
84409   jresult = (void *)result;
84410   return jresult;
84411 }
84412
84413
84414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
84415   void * jresult ;
84416   Dali::BaseHandle arg1 ;
84417   Dali::BaseHandle *argp1 ;
84418   Dali::Toolkit::Popup result;
84419
84420   argp1 = (Dali::BaseHandle *)jarg1;
84421   if (!argp1) {
84422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84423     return 0;
84424   }
84425   arg1 = *argp1;
84426   {
84427     try {
84428       result = Dali::Toolkit::Popup::DownCast(arg1);
84429     } catch (std::out_of_range& e) {
84430       {
84431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84432       };
84433     } catch (std::exception& e) {
84434       {
84435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84436       };
84437     } catch (Dali::DaliException e) {
84438       {
84439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84440       };
84441     } catch (...) {
84442       {
84443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84444       };
84445     }
84446   }
84447
84448   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
84449   return jresult;
84450 }
84451
84452
84453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
84454   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
84455   Dali::Actor arg2 ;
84456   Dali::Actor *argp2 ;
84457
84458   arg1 = (Dali::Toolkit::Popup *)jarg1;
84459   argp2 = (Dali::Actor *)jarg2;
84460   if (!argp2) {
84461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84462     return ;
84463   }
84464   arg2 = *argp2;
84465   {
84466     try {
84467       (arg1)->SetTitle(arg2);
84468     } catch (std::out_of_range& e) {
84469       {
84470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84471       };
84472     } catch (std::exception& e) {
84473       {
84474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84475       };
84476     } catch (Dali::DaliException e) {
84477       {
84478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84479       };
84480     } catch (...) {
84481       {
84482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84483       };
84484     }
84485   }
84486
84487 }
84488
84489
84490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
84491   void * jresult ;
84492   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
84493   Dali::Actor result;
84494
84495   arg1 = (Dali::Toolkit::Popup *)jarg1;
84496   {
84497     try {
84498       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
84499     } catch (std::out_of_range& e) {
84500       {
84501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84502       };
84503     } catch (std::exception& e) {
84504       {
84505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84506       };
84507     } catch (Dali::DaliException e) {
84508       {
84509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84510       };
84511     } catch (...) {
84512       {
84513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84514       };
84515     }
84516   }
84517
84518   jresult = new Dali::Actor((const Dali::Actor &)result);
84519   return jresult;
84520 }
84521
84522
84523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
84524   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
84525   Dali::Actor arg2 ;
84526   Dali::Actor *argp2 ;
84527
84528   arg1 = (Dali::Toolkit::Popup *)jarg1;
84529   argp2 = (Dali::Actor *)jarg2;
84530   if (!argp2) {
84531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84532     return ;
84533   }
84534   arg2 = *argp2;
84535   {
84536     try {
84537       (arg1)->SetContent(arg2);
84538     } catch (std::out_of_range& e) {
84539       {
84540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84541       };
84542     } catch (std::exception& e) {
84543       {
84544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84545       };
84546     } catch (Dali::DaliException e) {
84547       {
84548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84549       };
84550     } catch (...) {
84551       {
84552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84553       };
84554     }
84555   }
84556
84557 }
84558
84559
84560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
84561   void * jresult ;
84562   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
84563   Dali::Actor result;
84564
84565   arg1 = (Dali::Toolkit::Popup *)jarg1;
84566   {
84567     try {
84568       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
84569     } catch (std::out_of_range& e) {
84570       {
84571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84572       };
84573     } catch (std::exception& e) {
84574       {
84575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84576       };
84577     } catch (Dali::DaliException e) {
84578       {
84579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84580       };
84581     } catch (...) {
84582       {
84583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84584       };
84585     }
84586   }
84587
84588   jresult = new Dali::Actor((const Dali::Actor &)result);
84589   return jresult;
84590 }
84591
84592
84593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
84594   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
84595   Dali::Actor arg2 ;
84596   Dali::Actor *argp2 ;
84597
84598   arg1 = (Dali::Toolkit::Popup *)jarg1;
84599   argp2 = (Dali::Actor *)jarg2;
84600   if (!argp2) {
84601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84602     return ;
84603   }
84604   arg2 = *argp2;
84605   {
84606     try {
84607       (arg1)->SetFooter(arg2);
84608     } catch (std::out_of_range& e) {
84609       {
84610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84611       };
84612     } catch (std::exception& e) {
84613       {
84614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84615       };
84616     } catch (Dali::DaliException e) {
84617       {
84618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84619       };
84620     } catch (...) {
84621       {
84622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84623       };
84624     }
84625   }
84626
84627 }
84628
84629
84630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
84631   void * jresult ;
84632   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
84633   Dali::Actor result;
84634
84635   arg1 = (Dali::Toolkit::Popup *)jarg1;
84636   {
84637     try {
84638       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
84639     } catch (std::out_of_range& e) {
84640       {
84641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84642       };
84643     } catch (std::exception& e) {
84644       {
84645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84646       };
84647     } catch (Dali::DaliException e) {
84648       {
84649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84650       };
84651     } catch (...) {
84652       {
84653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84654       };
84655     }
84656   }
84657
84658   jresult = new Dali::Actor((const Dali::Actor &)result);
84659   return jresult;
84660 }
84661
84662
84663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
84664   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
84665   Dali::Toolkit::Popup::DisplayState arg2 ;
84666
84667   arg1 = (Dali::Toolkit::Popup *)jarg1;
84668   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
84669   {
84670     try {
84671       (arg1)->SetDisplayState(arg2);
84672     } catch (std::out_of_range& e) {
84673       {
84674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84675       };
84676     } catch (std::exception& e) {
84677       {
84678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84679       };
84680     } catch (Dali::DaliException e) {
84681       {
84682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84683       };
84684     } catch (...) {
84685       {
84686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84687       };
84688     }
84689   }
84690
84691 }
84692
84693
84694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
84695   int jresult ;
84696   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
84697   Dali::Toolkit::Popup::DisplayState result;
84698
84699   arg1 = (Dali::Toolkit::Popup *)jarg1;
84700   {
84701     try {
84702       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
84703     } catch (std::out_of_range& e) {
84704       {
84705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84706       };
84707     } catch (std::exception& e) {
84708       {
84709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84710       };
84711     } catch (Dali::DaliException e) {
84712       {
84713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84714       };
84715     } catch (...) {
84716       {
84717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84718       };
84719     }
84720   }
84721
84722   jresult = (int)result;
84723   return jresult;
84724 }
84725
84726
84727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
84728   void * jresult ;
84729   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
84730   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
84731
84732   arg1 = (Dali::Toolkit::Popup *)jarg1;
84733   {
84734     try {
84735       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
84736     } catch (std::out_of_range& e) {
84737       {
84738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84739       };
84740     } catch (std::exception& e) {
84741       {
84742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84743       };
84744     } catch (Dali::DaliException e) {
84745       {
84746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84747       };
84748     } catch (...) {
84749       {
84750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84751       };
84752     }
84753   }
84754
84755   jresult = (void *)result;
84756   return jresult;
84757 }
84758
84759
84760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
84761   void * jresult ;
84762   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
84763   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
84764
84765   arg1 = (Dali::Toolkit::Popup *)jarg1;
84766   {
84767     try {
84768       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
84769     } catch (std::out_of_range& e) {
84770       {
84771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84772       };
84773     } catch (std::exception& e) {
84774       {
84775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84776       };
84777     } catch (Dali::DaliException e) {
84778       {
84779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84780       };
84781     } catch (...) {
84782       {
84783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84784       };
84785     }
84786   }
84787
84788   jresult = (void *)result;
84789   return jresult;
84790 }
84791
84792
84793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
84794   void * jresult ;
84795   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
84796   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
84797
84798   arg1 = (Dali::Toolkit::Popup *)jarg1;
84799   {
84800     try {
84801       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
84802     } catch (std::out_of_range& e) {
84803       {
84804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84805       };
84806     } catch (std::exception& e) {
84807       {
84808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84809       };
84810     } catch (Dali::DaliException e) {
84811       {
84812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84813       };
84814     } catch (...) {
84815       {
84816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84817       };
84818     }
84819   }
84820
84821   jresult = (void *)result;
84822   return jresult;
84823 }
84824
84825
84826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
84827   void * jresult ;
84828   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
84829   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
84830
84831   arg1 = (Dali::Toolkit::Popup *)jarg1;
84832   {
84833     try {
84834       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
84835     } catch (std::out_of_range& e) {
84836       {
84837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84838       };
84839     } catch (std::exception& e) {
84840       {
84841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84842       };
84843     } catch (Dali::DaliException e) {
84844       {
84845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84846       };
84847     } catch (...) {
84848       {
84849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84850       };
84851     }
84852   }
84853
84854   jresult = (void *)result;
84855   return jresult;
84856 }
84857
84858
84859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
84860   void * jresult ;
84861   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
84862   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
84863
84864   arg1 = (Dali::Toolkit::Popup *)jarg1;
84865   {
84866     try {
84867       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
84868     } catch (std::out_of_range& e) {
84869       {
84870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84871       };
84872     } catch (std::exception& e) {
84873       {
84874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84875       };
84876     } catch (Dali::DaliException e) {
84877       {
84878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84879       };
84880     } catch (...) {
84881       {
84882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84883       };
84884     }
84885   }
84886
84887   jresult = (void *)result;
84888   return jresult;
84889 }
84890
84891
84892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
84893   int jresult ;
84894   int result;
84895
84896   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
84897   jresult = (int)result;
84898   return jresult;
84899 }
84900
84901
84902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
84903   int jresult ;
84904   int result;
84905
84906   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
84907   jresult = (int)result;
84908   return jresult;
84909 }
84910
84911
84912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
84913   int jresult ;
84914   int result;
84915
84916   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
84917   jresult = (int)result;
84918   return jresult;
84919 }
84920
84921
84922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
84923   int jresult ;
84924   int result;
84925
84926   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
84927   jresult = (int)result;
84928   return jresult;
84929 }
84930
84931
84932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
84933   int jresult ;
84934   int result;
84935
84936   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
84937   jresult = (int)result;
84938   return jresult;
84939 }
84940
84941
84942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
84943   int jresult ;
84944   int result;
84945
84946   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
84947   jresult = (int)result;
84948   return jresult;
84949 }
84950
84951
84952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
84953   int jresult ;
84954   int result;
84955
84956   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
84957   jresult = (int)result;
84958   return jresult;
84959 }
84960
84961
84962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
84963   int jresult ;
84964   int result;
84965
84966   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
84967   jresult = (int)result;
84968   return jresult;
84969 }
84970
84971
84972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
84973   int jresult ;
84974   int result;
84975
84976   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
84977   jresult = (int)result;
84978   return jresult;
84979 }
84980
84981
84982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
84983   void * jresult ;
84984   Dali::Toolkit::ProgressBar::Property *result = 0 ;
84985
84986   {
84987     try {
84988       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
84989     } catch (std::out_of_range& e) {
84990       {
84991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84992       };
84993     } catch (std::exception& e) {
84994       {
84995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84996       };
84997     } catch (Dali::DaliException e) {
84998       {
84999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85000       };
85001     } catch (...) {
85002       {
85003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85004       };
85005     }
85006   }
85007
85008   jresult = (void *)result;
85009   return jresult;
85010 }
85011
85012
85013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
85014   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
85015
85016   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
85017   {
85018     try {
85019       delete arg1;
85020     } catch (std::out_of_range& e) {
85021       {
85022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85023       };
85024     } catch (std::exception& e) {
85025       {
85026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85027       };
85028     } catch (Dali::DaliException e) {
85029       {
85030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85031       };
85032     } catch (...) {
85033       {
85034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85035       };
85036     }
85037   }
85038
85039 }
85040
85041
85042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
85043   void * jresult ;
85044   Dali::Toolkit::ProgressBar result;
85045
85046   {
85047     try {
85048       result = Dali::Toolkit::ProgressBar::New();
85049     } catch (std::out_of_range& e) {
85050       {
85051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85052       };
85053     } catch (std::exception& e) {
85054       {
85055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85056       };
85057     } catch (Dali::DaliException e) {
85058       {
85059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85060       };
85061     } catch (...) {
85062       {
85063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85064       };
85065     }
85066   }
85067
85068   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
85069   return jresult;
85070 }
85071
85072
85073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
85074   void * jresult ;
85075   Dali::Toolkit::ProgressBar *result = 0 ;
85076
85077   {
85078     try {
85079       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
85080     } catch (std::out_of_range& e) {
85081       {
85082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85083       };
85084     } catch (std::exception& e) {
85085       {
85086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85087       };
85088     } catch (Dali::DaliException e) {
85089       {
85090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85091       };
85092     } catch (...) {
85093       {
85094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85095       };
85096     }
85097   }
85098
85099   jresult = (void *)result;
85100   return jresult;
85101 }
85102
85103
85104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
85105   void * jresult ;
85106   Dali::Toolkit::ProgressBar *arg1 = 0 ;
85107   Dali::Toolkit::ProgressBar *result = 0 ;
85108
85109   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
85110   if (!arg1) {
85111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
85112     return 0;
85113   }
85114   {
85115     try {
85116       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
85117     } catch (std::out_of_range& e) {
85118       {
85119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85120       };
85121     } catch (std::exception& e) {
85122       {
85123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85124       };
85125     } catch (Dali::DaliException e) {
85126       {
85127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85128       };
85129     } catch (...) {
85130       {
85131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85132       };
85133     }
85134   }
85135
85136   jresult = (void *)result;
85137   return jresult;
85138 }
85139
85140
85141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
85142   void * jresult ;
85143   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
85144   Dali::Toolkit::ProgressBar *arg2 = 0 ;
85145   Dali::Toolkit::ProgressBar *result = 0 ;
85146
85147   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
85148   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
85149   if (!arg2) {
85150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
85151     return 0;
85152   }
85153   {
85154     try {
85155       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
85156     } catch (std::out_of_range& e) {
85157       {
85158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85159       };
85160     } catch (std::exception& e) {
85161       {
85162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85163       };
85164     } catch (Dali::DaliException e) {
85165       {
85166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85167       };
85168     } catch (...) {
85169       {
85170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85171       };
85172     }
85173   }
85174
85175   jresult = (void *)result;
85176   return jresult;
85177 }
85178
85179
85180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
85181   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
85182
85183   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
85184   {
85185     try {
85186       delete arg1;
85187     } catch (std::out_of_range& e) {
85188       {
85189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85190       };
85191     } catch (std::exception& e) {
85192       {
85193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85194       };
85195     } catch (Dali::DaliException e) {
85196       {
85197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85198       };
85199     } catch (...) {
85200       {
85201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85202       };
85203     }
85204   }
85205
85206 }
85207
85208
85209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
85210   void * jresult ;
85211   Dali::BaseHandle arg1 ;
85212   Dali::BaseHandle *argp1 ;
85213   Dali::Toolkit::ProgressBar result;
85214
85215   argp1 = (Dali::BaseHandle *)jarg1;
85216   if (!argp1) {
85217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85218     return 0;
85219   }
85220   arg1 = *argp1;
85221   {
85222     try {
85223       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
85224     } catch (std::out_of_range& e) {
85225       {
85226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85227       };
85228     } catch (std::exception& e) {
85229       {
85230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85231       };
85232     } catch (Dali::DaliException e) {
85233       {
85234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85235       };
85236     } catch (...) {
85237       {
85238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85239       };
85240     }
85241   }
85242
85243   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
85244   return jresult;
85245 }
85246
85247
85248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
85249   void * jresult ;
85250   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
85251   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
85252
85253   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
85254   {
85255     try {
85256       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
85257     } catch (std::out_of_range& e) {
85258       {
85259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85260       };
85261     } catch (std::exception& e) {
85262       {
85263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85264       };
85265     } catch (Dali::DaliException e) {
85266       {
85267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85268       };
85269     } catch (...) {
85270       {
85271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85272       };
85273     }
85274   }
85275
85276   jresult = (void *)result;
85277   return jresult;
85278 }
85279
85280
85281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
85282   void * jresult ;
85283   Dali::Toolkit::GaussianBlurView *result = 0 ;
85284
85285   {
85286     try {
85287       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
85288     } catch (std::out_of_range& e) {
85289       {
85290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85291       };
85292     } catch (std::exception& e) {
85293       {
85294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85295       };
85296     } catch (Dali::DaliException e) {
85297       {
85298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85299       };
85300     } catch (...) {
85301       {
85302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85303       };
85304     }
85305   }
85306
85307   jresult = (void *)result;
85308   return jresult;
85309 }
85310
85311
85312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
85313   void * jresult ;
85314   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
85315   Dali::Toolkit::GaussianBlurView *result = 0 ;
85316
85317   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85318   if (!arg1) {
85319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
85320     return 0;
85321   }
85322   {
85323     try {
85324       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
85325     } catch (std::out_of_range& e) {
85326       {
85327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85328       };
85329     } catch (std::exception& e) {
85330       {
85331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85332       };
85333     } catch (Dali::DaliException e) {
85334       {
85335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85336       };
85337     } catch (...) {
85338       {
85339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85340       };
85341     }
85342   }
85343
85344   jresult = (void *)result;
85345   return jresult;
85346 }
85347
85348
85349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
85350   void * jresult ;
85351   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
85352   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
85353   Dali::Toolkit::GaussianBlurView *result = 0 ;
85354
85355   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85356   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
85357   if (!arg2) {
85358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
85359     return 0;
85360   }
85361   {
85362     try {
85363       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
85364     } catch (std::out_of_range& e) {
85365       {
85366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85367       };
85368     } catch (std::exception& e) {
85369       {
85370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85371       };
85372     } catch (Dali::DaliException e) {
85373       {
85374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85375       };
85376     } catch (...) {
85377       {
85378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85379       };
85380     }
85381   }
85382
85383   jresult = (void *)result;
85384   return jresult;
85385 }
85386
85387
85388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
85389   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
85390
85391   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85392   {
85393     try {
85394       delete arg1;
85395     } catch (std::out_of_range& e) {
85396       {
85397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85398       };
85399     } catch (std::exception& e) {
85400       {
85401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85402       };
85403     } catch (Dali::DaliException e) {
85404       {
85405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85406       };
85407     } catch (...) {
85408       {
85409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85410       };
85411     }
85412   }
85413
85414 }
85415
85416
85417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
85418   void * jresult ;
85419   Dali::BaseHandle arg1 ;
85420   Dali::BaseHandle *argp1 ;
85421   Dali::Toolkit::GaussianBlurView result;
85422
85423   argp1 = (Dali::BaseHandle *)jarg1;
85424   if (!argp1) {
85425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85426     return 0;
85427   }
85428   arg1 = *argp1;
85429   {
85430     try {
85431       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
85432     } catch (std::out_of_range& e) {
85433       {
85434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85435       };
85436     } catch (std::exception& e) {
85437       {
85438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85439       };
85440     } catch (Dali::DaliException e) {
85441       {
85442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85443       };
85444     } catch (...) {
85445       {
85446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85447       };
85448     }
85449   }
85450
85451   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
85452   return jresult;
85453 }
85454
85455
85456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
85457   void * jresult ;
85458   Dali::Toolkit::GaussianBlurView result;
85459
85460   {
85461     try {
85462       result = Dali::Toolkit::GaussianBlurView::New();
85463     } catch (std::out_of_range& e) {
85464       {
85465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85466       };
85467     } catch (std::exception& e) {
85468       {
85469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85470       };
85471     } catch (Dali::DaliException e) {
85472       {
85473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85474       };
85475     } catch (...) {
85476       {
85477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85478       };
85479     }
85480   }
85481
85482   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
85483   return jresult;
85484 }
85485
85486
85487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
85488   void * jresult ;
85489   unsigned int arg1 ;
85490   float arg2 ;
85491   Dali::Pixel::Format arg3 ;
85492   float arg4 ;
85493   float arg5 ;
85494   bool arg6 ;
85495   Dali::Toolkit::GaussianBlurView result;
85496
85497   arg1 = (unsigned int)jarg1;
85498   arg2 = (float)jarg2;
85499   arg3 = (Dali::Pixel::Format)jarg3;
85500   arg4 = (float)jarg4;
85501   arg5 = (float)jarg5;
85502   arg6 = jarg6 ? true : false;
85503   {
85504     try {
85505       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
85506     } catch (std::out_of_range& e) {
85507       {
85508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85509       };
85510     } catch (std::exception& e) {
85511       {
85512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85513       };
85514     } catch (Dali::DaliException e) {
85515       {
85516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85517       };
85518     } catch (...) {
85519       {
85520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85521       };
85522     }
85523   }
85524
85525   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
85526   return jresult;
85527 }
85528
85529
85530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
85531   void * jresult ;
85532   unsigned int arg1 ;
85533   float arg2 ;
85534   Dali::Pixel::Format arg3 ;
85535   float arg4 ;
85536   float arg5 ;
85537   Dali::Toolkit::GaussianBlurView result;
85538
85539   arg1 = (unsigned int)jarg1;
85540   arg2 = (float)jarg2;
85541   arg3 = (Dali::Pixel::Format)jarg3;
85542   arg4 = (float)jarg4;
85543   arg5 = (float)jarg5;
85544   {
85545     try {
85546       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
85547     } catch (std::out_of_range& e) {
85548       {
85549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85550       };
85551     } catch (std::exception& e) {
85552       {
85553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85554       };
85555     } catch (Dali::DaliException e) {
85556       {
85557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85558       };
85559     } catch (...) {
85560       {
85561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85562       };
85563     }
85564   }
85565
85566   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
85567   return jresult;
85568 }
85569
85570
85571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
85572   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
85573   Dali::Actor arg2 ;
85574   Dali::Actor *argp2 ;
85575
85576   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85577   argp2 = (Dali::Actor *)jarg2;
85578   if (!argp2) {
85579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85580     return ;
85581   }
85582   arg2 = *argp2;
85583   {
85584     try {
85585       (arg1)->Add(arg2);
85586     } catch (std::out_of_range& e) {
85587       {
85588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85589       };
85590     } catch (std::exception& e) {
85591       {
85592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85593       };
85594     } catch (Dali::DaliException e) {
85595       {
85596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85597       };
85598     } catch (...) {
85599       {
85600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85601       };
85602     }
85603   }
85604
85605 }
85606
85607
85608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
85609   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
85610   Dali::Actor arg2 ;
85611   Dali::Actor *argp2 ;
85612
85613   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85614   argp2 = (Dali::Actor *)jarg2;
85615   if (!argp2) {
85616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85617     return ;
85618   }
85619   arg2 = *argp2;
85620   {
85621     try {
85622       (arg1)->Remove(arg2);
85623     } catch (std::out_of_range& e) {
85624       {
85625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85626       };
85627     } catch (std::exception& e) {
85628       {
85629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85630       };
85631     } catch (Dali::DaliException e) {
85632       {
85633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85634       };
85635     } catch (...) {
85636       {
85637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85638       };
85639     }
85640   }
85641
85642 }
85643
85644
85645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
85646   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
85647
85648   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85649   {
85650     try {
85651       (arg1)->Activate();
85652     } catch (std::out_of_range& e) {
85653       {
85654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85655       };
85656     } catch (std::exception& e) {
85657       {
85658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85659       };
85660     } catch (Dali::DaliException e) {
85661       {
85662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85663       };
85664     } catch (...) {
85665       {
85666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85667       };
85668     }
85669   }
85670
85671 }
85672
85673
85674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
85675   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
85676
85677   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85678   {
85679     try {
85680       (arg1)->ActivateOnce();
85681     } catch (std::out_of_range& e) {
85682       {
85683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85684       };
85685     } catch (std::exception& e) {
85686       {
85687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85688       };
85689     } catch (Dali::DaliException e) {
85690       {
85691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85692       };
85693     } catch (...) {
85694       {
85695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85696       };
85697     }
85698   }
85699
85700 }
85701
85702
85703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
85704   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
85705
85706   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85707   {
85708     try {
85709       (arg1)->Deactivate();
85710     } catch (std::out_of_range& e) {
85711       {
85712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85713       };
85714     } catch (std::exception& e) {
85715       {
85716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85717       };
85718     } catch (Dali::DaliException e) {
85719       {
85720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85721       };
85722     } catch (...) {
85723       {
85724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85725       };
85726     }
85727   }
85728
85729 }
85730
85731
85732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
85733   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
85734   Dali::Texture arg2 ;
85735   Dali::FrameBuffer arg3 ;
85736   Dali::Texture *argp2 ;
85737   Dali::FrameBuffer *argp3 ;
85738
85739   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85740   argp2 = (Dali::Texture *)jarg2;
85741   if (!argp2) {
85742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
85743     return ;
85744   }
85745   arg2 = *argp2;
85746   argp3 = (Dali::FrameBuffer *)jarg3;
85747   if (!argp3) {
85748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
85749     return ;
85750   }
85751   arg3 = *argp3;
85752   {
85753     try {
85754       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
85755     } catch (std::out_of_range& e) {
85756       {
85757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85758       };
85759     } catch (std::exception& e) {
85760       {
85761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85762       };
85763     } catch (Dali::DaliException e) {
85764       {
85765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85766       };
85767     } catch (...) {
85768       {
85769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85770       };
85771     }
85772   }
85773
85774 }
85775
85776
85777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
85778   int jresult ;
85779   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
85780   Dali::Property::Index result;
85781
85782   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85783   {
85784     try {
85785       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
85786     } catch (std::out_of_range& e) {
85787       {
85788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85789       };
85790     } catch (std::exception& e) {
85791       {
85792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85793       };
85794     } catch (Dali::DaliException e) {
85795       {
85796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85797       };
85798     } catch (...) {
85799       {
85800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85801       };
85802     }
85803   }
85804
85805   jresult = result;
85806   return jresult;
85807 }
85808
85809
85810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
85811   void * jresult ;
85812   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
85813   Dali::FrameBuffer result;
85814
85815   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85816   {
85817     try {
85818       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
85819     } catch (std::out_of_range& e) {
85820       {
85821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85822       };
85823     } catch (std::exception& e) {
85824       {
85825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85826       };
85827     } catch (Dali::DaliException e) {
85828       {
85829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85830       };
85831     } catch (...) {
85832       {
85833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85834       };
85835     }
85836   }
85837
85838   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
85839   return jresult;
85840 }
85841
85842
85843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
85844   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
85845   Dali::Vector4 *arg2 = 0 ;
85846
85847   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85848   arg2 = (Dali::Vector4 *)jarg2;
85849   if (!arg2) {
85850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
85851     return ;
85852   }
85853   {
85854     try {
85855       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
85856     } catch (std::out_of_range& e) {
85857       {
85858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85859       };
85860     } catch (std::exception& e) {
85861       {
85862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85863       };
85864     } catch (Dali::DaliException e) {
85865       {
85866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85867       };
85868     } catch (...) {
85869       {
85870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85871       };
85872     }
85873   }
85874
85875 }
85876
85877
85878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
85879   void * jresult ;
85880   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
85881   Dali::Vector4 result;
85882
85883   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85884   {
85885     try {
85886       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
85887     } catch (std::out_of_range& e) {
85888       {
85889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85890       };
85891     } catch (std::exception& e) {
85892       {
85893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85894       };
85895     } catch (Dali::DaliException e) {
85896       {
85897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85898       };
85899     } catch (...) {
85900       {
85901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85902       };
85903     }
85904   }
85905
85906   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
85907   return jresult;
85908 }
85909
85910
85911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
85912   void * jresult ;
85913   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
85914   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
85915
85916   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85917   {
85918     try {
85919       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
85920     } catch (std::out_of_range& e) {
85921       {
85922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85923       };
85924     } catch (std::exception& e) {
85925       {
85926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85927       };
85928     } catch (Dali::DaliException e) {
85929       {
85930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85931       };
85932     } catch (...) {
85933       {
85934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85935       };
85936     }
85937   }
85938
85939   jresult = (void *)result;
85940   return jresult;
85941 }
85942
85943
85944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
85945   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
85946
85947   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85948   {
85949     try {
85950       delete arg1;
85951     } catch (std::out_of_range& e) {
85952       {
85953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85954       };
85955     } catch (std::exception& e) {
85956       {
85957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85958       };
85959     } catch (Dali::DaliException e) {
85960       {
85961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85962       };
85963     } catch (...) {
85964       {
85965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85966       };
85967     }
85968   }
85969
85970 }
85971
85972
85973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
85974   unsigned int jresult ;
85975   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
85976   unsigned int result;
85977
85978   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85979   {
85980     try {
85981       result = (unsigned int)(arg1)->GetNumberOfPages();
85982     } catch (std::out_of_range& e) {
85983       {
85984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85985       };
85986     } catch (std::exception& e) {
85987       {
85988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85989       };
85990     } catch (Dali::DaliException e) {
85991       {
85992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85993       };
85994     } catch (...) {
85995       {
85996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85997       };
85998     }
85999   }
86000
86001   jresult = result;
86002   return jresult;
86003 }
86004
86005
86006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
86007   void * jresult ;
86008   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
86009   unsigned int arg2 ;
86010   Dali::Texture result;
86011
86012   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
86013   arg2 = (unsigned int)jarg2;
86014   {
86015     try {
86016       result = (arg1)->NewPage(arg2);
86017     } catch (std::out_of_range& e) {
86018       {
86019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86020       };
86021     } catch (std::exception& e) {
86022       {
86023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86024       };
86025     } catch (Dali::DaliException e) {
86026       {
86027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86028       };
86029     } catch (...) {
86030       {
86031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86032       };
86033     }
86034   }
86035
86036   jresult = new Dali::Texture((const Dali::Texture &)result);
86037   return jresult;
86038 }
86039
86040
86041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
86042   int jresult ;
86043   int result;
86044
86045   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
86046   jresult = (int)result;
86047   return jresult;
86048 }
86049
86050
86051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
86052   int jresult ;
86053   int result;
86054
86055   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
86056   jresult = (int)result;
86057   return jresult;
86058 }
86059
86060
86061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
86062   int jresult ;
86063   int result;
86064
86065   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
86066   jresult = (int)result;
86067   return jresult;
86068 }
86069
86070
86071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
86072   void * jresult ;
86073   Dali::Toolkit::PageTurnView::Property *result = 0 ;
86074
86075   {
86076     try {
86077       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
86078     } catch (std::out_of_range& e) {
86079       {
86080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86081       };
86082     } catch (std::exception& e) {
86083       {
86084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86085       };
86086     } catch (Dali::DaliException e) {
86087       {
86088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86089       };
86090     } catch (...) {
86091       {
86092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86093       };
86094     }
86095   }
86096
86097   jresult = (void *)result;
86098   return jresult;
86099 }
86100
86101
86102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
86103   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
86104
86105   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
86106   {
86107     try {
86108       delete arg1;
86109     } catch (std::out_of_range& e) {
86110       {
86111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86112       };
86113     } catch (std::exception& e) {
86114       {
86115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86116       };
86117     } catch (Dali::DaliException e) {
86118       {
86119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86120       };
86121     } catch (...) {
86122       {
86123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86124       };
86125     }
86126   }
86127
86128 }
86129
86130
86131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
86132   void * jresult ;
86133   Dali::Toolkit::PageTurnView *result = 0 ;
86134
86135   {
86136     try {
86137       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
86138     } catch (std::out_of_range& e) {
86139       {
86140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86141       };
86142     } catch (std::exception& e) {
86143       {
86144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86145       };
86146     } catch (Dali::DaliException e) {
86147       {
86148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86149       };
86150     } catch (...) {
86151       {
86152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86153       };
86154     }
86155   }
86156
86157   jresult = (void *)result;
86158   return jresult;
86159 }
86160
86161
86162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
86163   void * jresult ;
86164   Dali::Toolkit::PageTurnView *arg1 = 0 ;
86165   Dali::Toolkit::PageTurnView *result = 0 ;
86166
86167   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
86168   if (!arg1) {
86169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
86170     return 0;
86171   }
86172   {
86173     try {
86174       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
86175     } catch (std::out_of_range& e) {
86176       {
86177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86178       };
86179     } catch (std::exception& e) {
86180       {
86181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86182       };
86183     } catch (Dali::DaliException e) {
86184       {
86185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86186       };
86187     } catch (...) {
86188       {
86189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86190       };
86191     }
86192   }
86193
86194   jresult = (void *)result;
86195   return jresult;
86196 }
86197
86198
86199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
86200   void * jresult ;
86201   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
86202   Dali::Toolkit::PageTurnView *arg2 = 0 ;
86203   Dali::Toolkit::PageTurnView *result = 0 ;
86204
86205   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
86206   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
86207   if (!arg2) {
86208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
86209     return 0;
86210   }
86211   {
86212     try {
86213       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
86214     } catch (std::out_of_range& e) {
86215       {
86216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86217       };
86218     } catch (std::exception& e) {
86219       {
86220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86221       };
86222     } catch (Dali::DaliException e) {
86223       {
86224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86225       };
86226     } catch (...) {
86227       {
86228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86229       };
86230     }
86231   }
86232
86233   jresult = (void *)result;
86234   return jresult;
86235 }
86236
86237
86238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
86239   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
86240
86241   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
86242   {
86243     try {
86244       delete arg1;
86245     } catch (std::out_of_range& e) {
86246       {
86247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86248       };
86249     } catch (std::exception& e) {
86250       {
86251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86252       };
86253     } catch (Dali::DaliException e) {
86254       {
86255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86256       };
86257     } catch (...) {
86258       {
86259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86260       };
86261     }
86262   }
86263
86264 }
86265
86266
86267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
86268   void * jresult ;
86269   Dali::BaseHandle arg1 ;
86270   Dali::BaseHandle *argp1 ;
86271   Dali::Toolkit::PageTurnView result;
86272
86273   argp1 = (Dali::BaseHandle *)jarg1;
86274   if (!argp1) {
86275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86276     return 0;
86277   }
86278   arg1 = *argp1;
86279   {
86280     try {
86281       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
86282     } catch (std::out_of_range& e) {
86283       {
86284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86285       };
86286     } catch (std::exception& e) {
86287       {
86288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86289       };
86290     } catch (Dali::DaliException e) {
86291       {
86292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86293       };
86294     } catch (...) {
86295       {
86296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86297       };
86298     }
86299   }
86300
86301   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
86302   return jresult;
86303 }
86304
86305
86306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
86307   void * jresult ;
86308   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
86309   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
86310
86311   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
86312   {
86313     try {
86314       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
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 = (void *)result;
86335   return jresult;
86336 }
86337
86338
86339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
86340   void * jresult ;
86341   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
86342   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
86343
86344   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
86345   {
86346     try {
86347       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
86348     } catch (std::out_of_range& e) {
86349       {
86350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86351       };
86352     } catch (std::exception& e) {
86353       {
86354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86355       };
86356     } catch (Dali::DaliException e) {
86357       {
86358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86359       };
86360     } catch (...) {
86361       {
86362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86363       };
86364     }
86365   }
86366
86367   jresult = (void *)result;
86368   return jresult;
86369 }
86370
86371
86372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
86373   void * jresult ;
86374   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
86375   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
86376
86377   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
86378   {
86379     try {
86380       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
86381     } catch (std::out_of_range& e) {
86382       {
86383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86384       };
86385     } catch (std::exception& e) {
86386       {
86387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86388       };
86389     } catch (Dali::DaliException e) {
86390       {
86391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86392       };
86393     } catch (...) {
86394       {
86395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86396       };
86397     }
86398   }
86399
86400   jresult = (void *)result;
86401   return jresult;
86402 }
86403
86404
86405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
86406   void * jresult ;
86407   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
86408   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
86409
86410   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
86411   {
86412     try {
86413       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
86414     } catch (std::out_of_range& e) {
86415       {
86416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86417       };
86418     } catch (std::exception& e) {
86419       {
86420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86421       };
86422     } catch (Dali::DaliException e) {
86423       {
86424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86425       };
86426     } catch (...) {
86427       {
86428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86429       };
86430     }
86431   }
86432
86433   jresult = (void *)result;
86434   return jresult;
86435 }
86436
86437
86438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
86439   void * jresult ;
86440   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
86441
86442   {
86443     try {
86444       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
86445     } catch (std::out_of_range& e) {
86446       {
86447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86448       };
86449     } catch (std::exception& e) {
86450       {
86451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86452       };
86453     } catch (Dali::DaliException e) {
86454       {
86455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86456       };
86457     } catch (...) {
86458       {
86459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86460       };
86461     }
86462   }
86463
86464   jresult = (void *)result;
86465   return jresult;
86466 }
86467
86468
86469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
86470   void * jresult ;
86471   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
86472   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
86473
86474   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
86475   if (!arg1) {
86476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
86477     return 0;
86478   }
86479   {
86480     try {
86481       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
86482     } catch (std::out_of_range& e) {
86483       {
86484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86485       };
86486     } catch (std::exception& e) {
86487       {
86488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86489       };
86490     } catch (Dali::DaliException e) {
86491       {
86492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86493       };
86494     } catch (...) {
86495       {
86496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86497       };
86498     }
86499   }
86500
86501   jresult = (void *)result;
86502   return jresult;
86503 }
86504
86505
86506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
86507   void * jresult ;
86508   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
86509   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
86510   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
86511
86512   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
86513   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
86514   if (!arg2) {
86515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
86516     return 0;
86517   }
86518   {
86519     try {
86520       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
86521     } catch (std::out_of_range& e) {
86522       {
86523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86524       };
86525     } catch (std::exception& e) {
86526       {
86527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86528       };
86529     } catch (Dali::DaliException e) {
86530       {
86531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86532       };
86533     } catch (...) {
86534       {
86535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86536       };
86537     }
86538   }
86539
86540   jresult = (void *)result;
86541   return jresult;
86542 }
86543
86544
86545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
86546   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
86547
86548   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
86549   {
86550     try {
86551       delete arg1;
86552     } catch (std::out_of_range& e) {
86553       {
86554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86555       };
86556     } catch (std::exception& e) {
86557       {
86558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86559       };
86560     } catch (Dali::DaliException e) {
86561       {
86562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86563       };
86564     } catch (...) {
86565       {
86566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86567       };
86568     }
86569   }
86570
86571 }
86572
86573
86574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
86575   void * jresult ;
86576   Dali::Toolkit::PageFactory *arg1 = 0 ;
86577   Dali::Vector2 *arg2 = 0 ;
86578   Dali::Toolkit::PageTurnLandscapeView result;
86579
86580   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
86581   if (!arg1) {
86582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
86583     return 0;
86584   }
86585   arg2 = (Dali::Vector2 *)jarg2;
86586   if (!arg2) {
86587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
86588     return 0;
86589   }
86590   {
86591     try {
86592       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
86593     } catch (std::out_of_range& e) {
86594       {
86595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86596       };
86597     } catch (std::exception& e) {
86598       {
86599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86600       };
86601     } catch (Dali::DaliException e) {
86602       {
86603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86604       };
86605     } catch (...) {
86606       {
86607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86608       };
86609     }
86610   }
86611
86612   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
86613   return jresult;
86614 }
86615
86616
86617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
86618   void * jresult ;
86619   Dali::BaseHandle arg1 ;
86620   Dali::BaseHandle *argp1 ;
86621   Dali::Toolkit::PageTurnLandscapeView result;
86622
86623   argp1 = (Dali::BaseHandle *)jarg1;
86624   if (!argp1) {
86625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86626     return 0;
86627   }
86628   arg1 = *argp1;
86629   {
86630     try {
86631       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
86632     } catch (std::out_of_range& e) {
86633       {
86634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86635       };
86636     } catch (std::exception& e) {
86637       {
86638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86639       };
86640     } catch (Dali::DaliException e) {
86641       {
86642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86643       };
86644     } catch (...) {
86645       {
86646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86647       };
86648     }
86649   }
86650
86651   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
86652   return jresult;
86653 }
86654
86655
86656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
86657   void * jresult ;
86658   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
86659
86660   {
86661     try {
86662       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
86663     } catch (std::out_of_range& e) {
86664       {
86665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86666       };
86667     } catch (std::exception& e) {
86668       {
86669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86670       };
86671     } catch (Dali::DaliException e) {
86672       {
86673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86674       };
86675     } catch (...) {
86676       {
86677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86678       };
86679     }
86680   }
86681
86682   jresult = (void *)result;
86683   return jresult;
86684 }
86685
86686
86687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
86688   void * jresult ;
86689   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
86690   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
86691
86692   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
86693   if (!arg1) {
86694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
86695     return 0;
86696   }
86697   {
86698     try {
86699       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
86700     } catch (std::out_of_range& e) {
86701       {
86702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86703       };
86704     } catch (std::exception& e) {
86705       {
86706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86707       };
86708     } catch (Dali::DaliException e) {
86709       {
86710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86711       };
86712     } catch (...) {
86713       {
86714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86715       };
86716     }
86717   }
86718
86719   jresult = (void *)result;
86720   return jresult;
86721 }
86722
86723
86724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
86725   void * jresult ;
86726   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
86727   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
86728   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
86729
86730   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
86731   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
86732   if (!arg2) {
86733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
86734     return 0;
86735   }
86736   {
86737     try {
86738       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
86739     } catch (std::out_of_range& e) {
86740       {
86741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86742       };
86743     } catch (std::exception& e) {
86744       {
86745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86746       };
86747     } catch (Dali::DaliException e) {
86748       {
86749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86750       };
86751     } catch (...) {
86752       {
86753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86754       };
86755     }
86756   }
86757
86758   jresult = (void *)result;
86759   return jresult;
86760 }
86761
86762
86763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
86764   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
86765
86766   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
86767   {
86768     try {
86769       delete arg1;
86770     } catch (std::out_of_range& e) {
86771       {
86772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86773       };
86774     } catch (std::exception& e) {
86775       {
86776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86777       };
86778     } catch (Dali::DaliException e) {
86779       {
86780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86781       };
86782     } catch (...) {
86783       {
86784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86785       };
86786     }
86787   }
86788
86789 }
86790
86791
86792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
86793   void * jresult ;
86794   Dali::Toolkit::PageFactory *arg1 = 0 ;
86795   Dali::Vector2 *arg2 = 0 ;
86796   Dali::Toolkit::PageTurnPortraitView result;
86797
86798   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
86799   if (!arg1) {
86800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
86801     return 0;
86802   }
86803   arg2 = (Dali::Vector2 *)jarg2;
86804   if (!arg2) {
86805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
86806     return 0;
86807   }
86808   {
86809     try {
86810       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
86811     } catch (std::out_of_range& e) {
86812       {
86813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86814       };
86815     } catch (std::exception& e) {
86816       {
86817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86818       };
86819     } catch (Dali::DaliException e) {
86820       {
86821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86822       };
86823     } catch (...) {
86824       {
86825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86826       };
86827     }
86828   }
86829
86830   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
86831   return jresult;
86832 }
86833
86834
86835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
86836   void * jresult ;
86837   Dali::BaseHandle arg1 ;
86838   Dali::BaseHandle *argp1 ;
86839   Dali::Toolkit::PageTurnPortraitView result;
86840
86841   argp1 = (Dali::BaseHandle *)jarg1;
86842   if (!argp1) {
86843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86844     return 0;
86845   }
86846   arg1 = *argp1;
86847   {
86848     try {
86849       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
86850     } catch (std::out_of_range& e) {
86851       {
86852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86853       };
86854     } catch (std::exception& e) {
86855       {
86856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86857       };
86858     } catch (Dali::DaliException e) {
86859       {
86860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86861       };
86862     } catch (...) {
86863       {
86864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86865       };
86866     }
86867   }
86868
86869   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
86870   return jresult;
86871 }
86872
86873
86874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
86875   int jresult ;
86876   int result;
86877
86878   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
86879   jresult = (int)result;
86880   return jresult;
86881 }
86882
86883
86884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
86885   int jresult ;
86886   int result;
86887
86888   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
86889   jresult = (int)result;
86890   return jresult;
86891 }
86892
86893
86894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
86895   int jresult ;
86896   int result;
86897
86898   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
86899   jresult = (int)result;
86900   return jresult;
86901 }
86902
86903
86904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
86905   void * jresult ;
86906   Dali::Toolkit::ToggleButton::Property *result = 0 ;
86907
86908   {
86909     try {
86910       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
86911     } catch (std::out_of_range& e) {
86912       {
86913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86914       };
86915     } catch (std::exception& e) {
86916       {
86917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86918       };
86919     } catch (Dali::DaliException e) {
86920       {
86921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86922       };
86923     } catch (...) {
86924       {
86925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86926       };
86927     }
86928   }
86929
86930   jresult = (void *)result;
86931   return jresult;
86932 }
86933
86934
86935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
86936   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
86937
86938   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
86939   {
86940     try {
86941       delete arg1;
86942     } catch (std::out_of_range& e) {
86943       {
86944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86945       };
86946     } catch (std::exception& e) {
86947       {
86948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86949       };
86950     } catch (Dali::DaliException e) {
86951       {
86952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86953       };
86954     } catch (...) {
86955       {
86956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86957       };
86958     }
86959   }
86960
86961 }
86962
86963
86964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
86965   void * jresult ;
86966   Dali::Toolkit::ToggleButton *result = 0 ;
86967
86968   {
86969     try {
86970       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
86971     } catch (std::out_of_range& e) {
86972       {
86973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86974       };
86975     } catch (std::exception& e) {
86976       {
86977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86978       };
86979     } catch (Dali::DaliException e) {
86980       {
86981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86982       };
86983     } catch (...) {
86984       {
86985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86986       };
86987     }
86988   }
86989
86990   jresult = (void *)result;
86991   return jresult;
86992 }
86993
86994
86995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
86996   void * jresult ;
86997   Dali::Toolkit::ToggleButton *arg1 = 0 ;
86998   Dali::Toolkit::ToggleButton *result = 0 ;
86999
87000   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
87001   if (!arg1) {
87002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
87003     return 0;
87004   }
87005   {
87006     try {
87007       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
87008     } catch (std::out_of_range& e) {
87009       {
87010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87011       };
87012     } catch (std::exception& e) {
87013       {
87014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87015       };
87016     } catch (Dali::DaliException e) {
87017       {
87018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87019       };
87020     } catch (...) {
87021       {
87022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87023       };
87024     }
87025   }
87026
87027   jresult = (void *)result;
87028   return jresult;
87029 }
87030
87031
87032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
87033   void * jresult ;
87034   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
87035   Dali::Toolkit::ToggleButton *arg2 = 0 ;
87036   Dali::Toolkit::ToggleButton *result = 0 ;
87037
87038   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
87039   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
87040   if (!arg2) {
87041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
87042     return 0;
87043   }
87044   {
87045     try {
87046       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
87047     } catch (std::out_of_range& e) {
87048       {
87049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87050       };
87051     } catch (std::exception& e) {
87052       {
87053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87054       };
87055     } catch (Dali::DaliException e) {
87056       {
87057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87058       };
87059     } catch (...) {
87060       {
87061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87062       };
87063     }
87064   }
87065
87066   jresult = (void *)result;
87067   return jresult;
87068 }
87069
87070
87071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
87072   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
87073
87074   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
87075   {
87076     try {
87077       delete arg1;
87078     } catch (std::out_of_range& e) {
87079       {
87080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87081       };
87082     } catch (std::exception& e) {
87083       {
87084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87085       };
87086     } catch (Dali::DaliException e) {
87087       {
87088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87089       };
87090     } catch (...) {
87091       {
87092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87093       };
87094     }
87095   }
87096
87097 }
87098
87099
87100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
87101   void * jresult ;
87102   Dali::Toolkit::ToggleButton result;
87103
87104   {
87105     try {
87106       result = Dali::Toolkit::ToggleButton::New();
87107     } catch (std::out_of_range& e) {
87108       {
87109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87110       };
87111     } catch (std::exception& e) {
87112       {
87113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87114       };
87115     } catch (Dali::DaliException e) {
87116       {
87117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87118       };
87119     } catch (...) {
87120       {
87121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87122       };
87123     }
87124   }
87125
87126   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
87127   return jresult;
87128 }
87129
87130
87131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
87132   void * jresult ;
87133   Dali::BaseHandle arg1 ;
87134   Dali::BaseHandle *argp1 ;
87135   Dali::Toolkit::ToggleButton result;
87136
87137   argp1 = (Dali::BaseHandle *)jarg1;
87138   if (!argp1) {
87139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87140     return 0;
87141   }
87142   arg1 = *argp1;
87143   {
87144     try {
87145       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
87146     } catch (std::out_of_range& e) {
87147       {
87148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87149       };
87150     } catch (std::exception& e) {
87151       {
87152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87153       };
87154     } catch (Dali::DaliException e) {
87155       {
87156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87157       };
87158     } catch (...) {
87159       {
87160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87161       };
87162     }
87163   }
87164
87165   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
87166   return jresult;
87167 }
87168
87169
87170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
87171   void * jresult ;
87172   Dali::Toolkit::Visual::Base *result = 0 ;
87173
87174   {
87175     try {
87176       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
87177     } catch (std::out_of_range& e) {
87178       {
87179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87180       };
87181     } catch (std::exception& e) {
87182       {
87183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87184       };
87185     } catch (Dali::DaliException e) {
87186       {
87187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87188       };
87189     } catch (...) {
87190       {
87191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87192       };
87193     }
87194   }
87195
87196   jresult = (void *)result;
87197   return jresult;
87198 }
87199
87200
87201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
87202   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
87203
87204   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
87205   {
87206     try {
87207       delete arg1;
87208     } catch (std::out_of_range& e) {
87209       {
87210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87211       };
87212     } catch (std::exception& e) {
87213       {
87214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87215       };
87216     } catch (Dali::DaliException e) {
87217       {
87218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87219       };
87220     } catch (...) {
87221       {
87222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87223       };
87224     }
87225   }
87226
87227 }
87228
87229
87230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
87231   void * jresult ;
87232   Dali::Toolkit::Visual::Base *arg1 = 0 ;
87233   Dali::Toolkit::Visual::Base *result = 0 ;
87234
87235   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
87236   if (!arg1) {
87237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
87238     return 0;
87239   }
87240   {
87241     try {
87242       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
87243     } catch (std::out_of_range& e) {
87244       {
87245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87246       };
87247     } catch (std::exception& e) {
87248       {
87249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87250       };
87251     } catch (Dali::DaliException e) {
87252       {
87253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87254       };
87255     } catch (...) {
87256       {
87257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87258       };
87259     }
87260   }
87261
87262   jresult = (void *)result;
87263   return jresult;
87264 }
87265
87266
87267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
87268   void * jresult ;
87269   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
87270   Dali::Toolkit::Visual::Base *arg2 = 0 ;
87271   Dali::Toolkit::Visual::Base *result = 0 ;
87272
87273   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
87274   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
87275   if (!arg2) {
87276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
87277     return 0;
87278   }
87279   {
87280     try {
87281       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
87282     } catch (std::out_of_range& e) {
87283       {
87284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87285       };
87286     } catch (std::exception& e) {
87287       {
87288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87289       };
87290     } catch (Dali::DaliException e) {
87291       {
87292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87293       };
87294     } catch (...) {
87295       {
87296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87297       };
87298     }
87299   }
87300
87301   jresult = (void *)result;
87302   return jresult;
87303 }
87304
87305
87306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
87307   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
87308   std::string *arg2 = 0 ;
87309
87310   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
87311   if (!jarg2) {
87312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87313     return ;
87314   }
87315   std::string arg2_str(jarg2);
87316   arg2 = &arg2_str;
87317   {
87318     try {
87319       (arg1)->SetName((std::string const &)*arg2);
87320     } catch (std::out_of_range& e) {
87321       {
87322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87323       };
87324     } catch (std::exception& e) {
87325       {
87326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87327       };
87328     } catch (Dali::DaliException e) {
87329       {
87330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87331       };
87332     } catch (...) {
87333       {
87334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87335       };
87336     }
87337   }
87338
87339
87340   //argout typemap for const std::string&
87341
87342 }
87343
87344
87345 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
87346   char * jresult ;
87347   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
87348   std::string *result = 0 ;
87349
87350   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
87351   {
87352     try {
87353       result = (std::string *) &(arg1)->GetName();
87354     } catch (std::out_of_range& e) {
87355       {
87356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87357       };
87358     } catch (std::exception& e) {
87359       {
87360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87361       };
87362     } catch (Dali::DaliException e) {
87363       {
87364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87365       };
87366     } catch (...) {
87367       {
87368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87369       };
87370     }
87371   }
87372
87373   jresult = SWIG_csharp_string_callback(result->c_str());
87374   return jresult;
87375 }
87376
87377
87378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
87379   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
87380   Dali::Property::Map *arg2 = 0 ;
87381   Dali::Size arg3 ;
87382   Dali::Size *argp3 ;
87383
87384   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
87385   arg2 = (Dali::Property::Map *)jarg2;
87386   if (!arg2) {
87387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
87388     return ;
87389   }
87390   argp3 = (Dali::Size *)jarg3;
87391   if (!argp3) {
87392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
87393     return ;
87394   }
87395   arg3 = *argp3;
87396   {
87397     try {
87398       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
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 float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
87422   float jresult ;
87423   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
87424   float arg2 ;
87425   float result;
87426
87427   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
87428   arg2 = (float)jarg2;
87429   {
87430     try {
87431       result = (float)(arg1)->GetHeightForWidth(arg2);
87432     } catch (std::out_of_range& e) {
87433       {
87434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87435       };
87436     } catch (std::exception& e) {
87437       {
87438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87439       };
87440     } catch (Dali::DaliException e) {
87441       {
87442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87443       };
87444     } catch (...) {
87445       {
87446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87447       };
87448     }
87449   }
87450
87451   jresult = result;
87452   return jresult;
87453 }
87454
87455
87456 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
87457   float jresult ;
87458   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
87459   float arg2 ;
87460   float result;
87461
87462   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
87463   arg2 = (float)jarg2;
87464   {
87465     try {
87466       result = (float)(arg1)->GetWidthForHeight(arg2);
87467     } catch (std::out_of_range& e) {
87468       {
87469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87470       };
87471     } catch (std::exception& e) {
87472       {
87473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87474       };
87475     } catch (Dali::DaliException e) {
87476       {
87477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87478       };
87479     } catch (...) {
87480       {
87481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87482       };
87483     }
87484   }
87485
87486   jresult = result;
87487   return jresult;
87488 }
87489
87490
87491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
87492   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
87493   Dali::Vector2 *arg2 = 0 ;
87494
87495   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
87496   arg2 = (Dali::Vector2 *)jarg2;
87497   if (!arg2) {
87498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
87499     return ;
87500   }
87501   {
87502     try {
87503       (arg1)->GetNaturalSize(*arg2);
87504     } catch (std::out_of_range& e) {
87505       {
87506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87507       };
87508     } catch (std::exception& e) {
87509       {
87510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87511       };
87512     } catch (Dali::DaliException e) {
87513       {
87514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87515       };
87516     } catch (...) {
87517       {
87518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87519       };
87520     }
87521   }
87522
87523 }
87524
87525
87526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
87527   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
87528   float arg2 ;
87529
87530   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
87531   arg2 = (int)jarg2;
87532   {
87533     try {
87534       (arg1)->SetDepthIndex(arg2);
87535     } catch (std::out_of_range& e) {
87536       {
87537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87538       };
87539     } catch (std::exception& e) {
87540       {
87541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87542       };
87543     } catch (Dali::DaliException e) {
87544       {
87545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87546       };
87547     } catch (...) {
87548       {
87549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87550       };
87551     }
87552   }
87553
87554 }
87555
87556
87557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
87558   int jresult ;
87559   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
87560   int result;
87561
87562   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
87563   {
87564     try {
87565       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
87566     } catch (std::out_of_range& e) {
87567       {
87568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87569       };
87570     } catch (std::exception& e) {
87571       {
87572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87573       };
87574     } catch (Dali::DaliException e) {
87575       {
87576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87577       };
87578     } catch (...) {
87579       {
87580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87581       };
87582     }
87583   }
87584
87585   jresult = result;
87586   return jresult;
87587 }
87588
87589
87590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
87591   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
87592   Dali::Property::Map *arg2 = 0 ;
87593
87594   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
87595   arg2 = (Dali::Property::Map *)jarg2;
87596   if (!arg2) {
87597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
87598     return ;
87599   }
87600   {
87601     try {
87602       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
87603     } catch (std::out_of_range& e) {
87604       {
87605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87606       };
87607     } catch (std::exception& e) {
87608       {
87609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87610       };
87611     } catch (Dali::DaliException e) {
87612       {
87613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87614       };
87615     } catch (...) {
87616       {
87617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87618       };
87619     }
87620   }
87621
87622 }
87623
87624
87625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
87626   void * jresult ;
87627   Dali::Toolkit::VisualFactory result;
87628
87629   {
87630     try {
87631       result = Dali::Toolkit::VisualFactory::Get();
87632     } catch (std::out_of_range& e) {
87633       {
87634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87635       };
87636     } catch (std::exception& e) {
87637       {
87638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87639       };
87640     } catch (Dali::DaliException e) {
87641       {
87642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87643       };
87644     } catch (...) {
87645       {
87646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87647       };
87648     }
87649   }
87650
87651   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
87652   return jresult;
87653 }
87654
87655
87656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
87657   void * jresult ;
87658   Dali::Toolkit::VisualFactory *result = 0 ;
87659
87660   {
87661     try {
87662       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
87663     } catch (std::out_of_range& e) {
87664       {
87665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87666       };
87667     } catch (std::exception& e) {
87668       {
87669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87670       };
87671     } catch (Dali::DaliException e) {
87672       {
87673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87674       };
87675     } catch (...) {
87676       {
87677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87678       };
87679     }
87680   }
87681
87682   jresult = (void *)result;
87683   return jresult;
87684 }
87685
87686
87687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
87688   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
87689
87690   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
87691   {
87692     try {
87693       delete arg1;
87694     } catch (std::out_of_range& e) {
87695       {
87696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87697       };
87698     } catch (std::exception& e) {
87699       {
87700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87701       };
87702     } catch (Dali::DaliException e) {
87703       {
87704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87705       };
87706     } catch (...) {
87707       {
87708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87709       };
87710     }
87711   }
87712
87713 }
87714
87715
87716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
87717   void * jresult ;
87718   Dali::Toolkit::VisualFactory *arg1 = 0 ;
87719   Dali::Toolkit::VisualFactory *result = 0 ;
87720
87721   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
87722   if (!arg1) {
87723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
87724     return 0;
87725   }
87726   {
87727     try {
87728       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
87729     } catch (std::out_of_range& e) {
87730       {
87731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87732       };
87733     } catch (std::exception& e) {
87734       {
87735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87736       };
87737     } catch (Dali::DaliException e) {
87738       {
87739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87740       };
87741     } catch (...) {
87742       {
87743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87744       };
87745     }
87746   }
87747
87748   jresult = (void *)result;
87749   return jresult;
87750 }
87751
87752
87753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
87754   void * jresult ;
87755   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
87756   Dali::Toolkit::VisualFactory *arg2 = 0 ;
87757   Dali::Toolkit::VisualFactory *result = 0 ;
87758
87759   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
87760   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
87761   if (!arg2) {
87762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
87763     return 0;
87764   }
87765   {
87766     try {
87767       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
87768     } catch (std::out_of_range& e) {
87769       {
87770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87771       };
87772     } catch (std::exception& e) {
87773       {
87774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87775       };
87776     } catch (Dali::DaliException e) {
87777       {
87778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87779       };
87780     } catch (...) {
87781       {
87782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87783       };
87784     }
87785   }
87786
87787   jresult = (void *)result;
87788   return jresult;
87789 }
87790
87791
87792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
87793   void * jresult ;
87794   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
87795   Dali::Property::Map *arg2 = 0 ;
87796   Dali::Toolkit::Visual::Base result;
87797
87798   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
87799   arg2 = (Dali::Property::Map *)jarg2;
87800   if (!arg2) {
87801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
87802     return 0;
87803   }
87804   {
87805     try {
87806       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
87807     } catch (std::out_of_range& e) {
87808       {
87809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87810       };
87811     } catch (std::exception& e) {
87812       {
87813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87814       };
87815     } catch (Dali::DaliException e) {
87816       {
87817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87818       };
87819     } catch (...) {
87820       {
87821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87822       };
87823     }
87824   }
87825
87826   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
87827   return jresult;
87828 }
87829
87830
87831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
87832   void * jresult ;
87833   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
87834   std::string *arg2 = 0 ;
87835   Dali::ImageDimensions arg3 ;
87836   Dali::ImageDimensions *argp3 ;
87837   Dali::Toolkit::Visual::Base result;
87838
87839   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
87840   if (!jarg2) {
87841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87842     return 0;
87843   }
87844   std::string arg2_str(jarg2);
87845   arg2 = &arg2_str;
87846   argp3 = (Dali::ImageDimensions *)jarg3;
87847   if (!argp3) {
87848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
87849     return 0;
87850   }
87851   arg3 = *argp3;
87852   {
87853     try {
87854       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
87855     } catch (std::out_of_range& e) {
87856       {
87857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87858       };
87859     } catch (std::exception& e) {
87860       {
87861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87862       };
87863     } catch (Dali::DaliException e) {
87864       {
87865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87866       };
87867     } catch (...) {
87868       {
87869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87870       };
87871     }
87872   }
87873
87874   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
87875
87876   //argout typemap for const std::string&
87877
87878   return jresult;
87879 }
87880
87881
87882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
87883   void * jresult ;
87884   Dali::Toolkit::AsyncImageLoader *result = 0 ;
87885
87886   {
87887     try {
87888       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
87889     } catch (std::out_of_range& e) {
87890       {
87891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87892       };
87893     } catch (std::exception& e) {
87894       {
87895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87896       };
87897     } catch (Dali::DaliException e) {
87898       {
87899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87900       };
87901     } catch (...) {
87902       {
87903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87904       };
87905     }
87906   }
87907
87908   jresult = (void *)result;
87909   return jresult;
87910 }
87911
87912
87913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
87914   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
87915
87916   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87917   {
87918     try {
87919       delete arg1;
87920     } catch (std::out_of_range& e) {
87921       {
87922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87923       };
87924     } catch (std::exception& e) {
87925       {
87926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87927       };
87928     } catch (Dali::DaliException e) {
87929       {
87930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87931       };
87932     } catch (...) {
87933       {
87934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87935       };
87936     }
87937   }
87938
87939 }
87940
87941
87942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
87943   void * jresult ;
87944   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
87945   Dali::Toolkit::AsyncImageLoader *result = 0 ;
87946
87947   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87948   if (!arg1) {
87949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
87950     return 0;
87951   }
87952   {
87953     try {
87954       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
87955     } catch (std::out_of_range& e) {
87956       {
87957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87958       };
87959     } catch (std::exception& e) {
87960       {
87961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87962       };
87963     } catch (Dali::DaliException e) {
87964       {
87965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87966       };
87967     } catch (...) {
87968       {
87969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87970       };
87971     }
87972   }
87973
87974   jresult = (void *)result;
87975   return jresult;
87976 }
87977
87978
87979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
87980   void * jresult ;
87981   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
87982   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
87983   Dali::Toolkit::AsyncImageLoader *result = 0 ;
87984
87985   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87986   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
87987   if (!arg2) {
87988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
87989     return 0;
87990   }
87991   {
87992     try {
87993       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
87994     } catch (std::out_of_range& e) {
87995       {
87996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87997       };
87998     } catch (std::exception& e) {
87999       {
88000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88001       };
88002     } catch (Dali::DaliException e) {
88003       {
88004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88005       };
88006     } catch (...) {
88007       {
88008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88009       };
88010     }
88011   }
88012
88013   jresult = (void *)result;
88014   return jresult;
88015 }
88016
88017
88018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
88019   void * jresult ;
88020   Dali::Toolkit::AsyncImageLoader result;
88021
88022   {
88023     try {
88024       result = Dali::Toolkit::AsyncImageLoader::New();
88025     } catch (std::out_of_range& e) {
88026       {
88027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88028       };
88029     } catch (std::exception& e) {
88030       {
88031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88032       };
88033     } catch (Dali::DaliException e) {
88034       {
88035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88036       };
88037     } catch (...) {
88038       {
88039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88040       };
88041     }
88042   }
88043
88044   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
88045   return jresult;
88046 }
88047
88048
88049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
88050   void * jresult ;
88051   Dali::BaseHandle arg1 ;
88052   Dali::BaseHandle *argp1 ;
88053   Dali::Toolkit::AsyncImageLoader result;
88054
88055   argp1 = (Dali::BaseHandle *)jarg1;
88056   if (!argp1) {
88057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88058     return 0;
88059   }
88060   arg1 = *argp1;
88061   {
88062     try {
88063       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
88064     } catch (std::out_of_range& e) {
88065       {
88066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88067       };
88068     } catch (std::exception& e) {
88069       {
88070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88071       };
88072     } catch (Dali::DaliException e) {
88073       {
88074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88075       };
88076     } catch (...) {
88077       {
88078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88079       };
88080     }
88081   }
88082
88083   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
88084   return jresult;
88085 }
88086
88087
88088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
88089   unsigned int jresult ;
88090   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
88091   std::string *arg2 = 0 ;
88092   uint32_t result;
88093
88094   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
88095   if (!jarg2) {
88096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
88097     return 0;
88098   }
88099   std::string arg2_str(jarg2);
88100   arg2 = &arg2_str;
88101   {
88102     try {
88103       result = (arg1)->Load((std::string const &)*arg2);
88104     } catch (std::out_of_range& e) {
88105       {
88106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88107       };
88108     } catch (std::exception& e) {
88109       {
88110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88111       };
88112     } catch (Dali::DaliException e) {
88113       {
88114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88115       };
88116     } catch (...) {
88117       {
88118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88119       };
88120     }
88121   }
88122
88123   jresult = result;
88124
88125   //argout typemap for const std::string&
88126
88127   return jresult;
88128 }
88129
88130
88131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
88132   unsigned int jresult ;
88133   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
88134   std::string *arg2 = 0 ;
88135   Dali::ImageDimensions arg3 ;
88136   Dali::ImageDimensions *argp3 ;
88137   uint32_t result;
88138
88139   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
88140   if (!jarg2) {
88141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
88142     return 0;
88143   }
88144   std::string arg2_str(jarg2);
88145   arg2 = &arg2_str;
88146   argp3 = (Dali::ImageDimensions *)jarg3;
88147   if (!argp3) {
88148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
88149     return 0;
88150   }
88151   arg3 = *argp3;
88152   {
88153     try {
88154       result = (arg1)->Load((std::string const &)*arg2,arg3);
88155     } catch (std::out_of_range& e) {
88156       {
88157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88158       };
88159     } catch (std::exception& e) {
88160       {
88161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88162       };
88163     } catch (Dali::DaliException e) {
88164       {
88165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88166       };
88167     } catch (...) {
88168       {
88169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88170       };
88171     }
88172   }
88173
88174   jresult = result;
88175
88176   //argout typemap for const std::string&
88177
88178   return jresult;
88179 }
88180
88181
88182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
88183   unsigned int jresult ;
88184   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
88185   std::string *arg2 = 0 ;
88186   Dali::ImageDimensions arg3 ;
88187   Dali::FittingMode::Type arg4 ;
88188   Dali::SamplingMode::Type arg5 ;
88189   bool arg6 ;
88190   Dali::ImageDimensions *argp3 ;
88191   uint32_t result;
88192
88193   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
88194   if (!jarg2) {
88195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
88196     return 0;
88197   }
88198   std::string arg2_str(jarg2);
88199   arg2 = &arg2_str;
88200   argp3 = (Dali::ImageDimensions *)jarg3;
88201   if (!argp3) {
88202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
88203     return 0;
88204   }
88205   arg3 = *argp3;
88206   arg4 = (Dali::FittingMode::Type)jarg4;
88207   arg5 = (Dali::SamplingMode::Type)jarg5;
88208   arg6 = jarg6 ? true : false;
88209   {
88210     try {
88211       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
88212     } catch (std::out_of_range& e) {
88213       {
88214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88215       };
88216     } catch (std::exception& e) {
88217       {
88218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88219       };
88220     } catch (Dali::DaliException e) {
88221       {
88222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88223       };
88224     } catch (...) {
88225       {
88226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88227       };
88228     }
88229   }
88230
88231   jresult = result;
88232
88233   //argout typemap for const std::string&
88234
88235   return jresult;
88236 }
88237
88238
88239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
88240   unsigned int jresult ;
88241   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
88242   uint32_t arg2 ;
88243   bool result;
88244
88245   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
88246   arg2 = (uint32_t)jarg2;
88247   {
88248     try {
88249       result = (bool)(arg1)->Cancel(arg2);
88250     } catch (std::out_of_range& e) {
88251       {
88252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88253       };
88254     } catch (std::exception& e) {
88255       {
88256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88257       };
88258     } catch (Dali::DaliException e) {
88259       {
88260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88261       };
88262     } catch (...) {
88263       {
88264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88265       };
88266     }
88267   }
88268
88269   jresult = result;
88270   return jresult;
88271 }
88272
88273
88274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
88275   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
88276
88277   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
88278   {
88279     try {
88280       (arg1)->CancelAll();
88281     } catch (std::out_of_range& e) {
88282       {
88283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88284       };
88285     } catch (std::exception& e) {
88286       {
88287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88288       };
88289     } catch (Dali::DaliException e) {
88290       {
88291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88292       };
88293     } catch (...) {
88294       {
88295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88296       };
88297     }
88298   }
88299
88300 }
88301
88302
88303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
88304   void * jresult ;
88305   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
88306   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
88307
88308   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
88309   {
88310     try {
88311       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
88312     } catch (std::out_of_range& e) {
88313       {
88314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88315       };
88316     } catch (std::exception& e) {
88317       {
88318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88319       };
88320     } catch (Dali::DaliException e) {
88321       {
88322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88323       };
88324     } catch (...) {
88325       {
88326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88327       };
88328     }
88329   }
88330
88331   jresult = (void *)result;
88332   return jresult;
88333 }
88334
88335
88336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
88337   void * jresult ;
88338   std::string *arg1 = 0 ;
88339   Dali::PixelData result;
88340
88341   if (!jarg1) {
88342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
88343     return 0;
88344   }
88345   std::string arg1_str(jarg1);
88346   arg1 = &arg1_str;
88347   {
88348     try {
88349       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
88350     } catch (std::out_of_range& e) {
88351       {
88352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88353       };
88354     } catch (std::exception& e) {
88355       {
88356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88357       };
88358     } catch (Dali::DaliException e) {
88359       {
88360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88361       };
88362     } catch (...) {
88363       {
88364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88365       };
88366     }
88367   }
88368
88369   jresult = new Dali::PixelData((const Dali::PixelData &)result);
88370
88371   //argout typemap for const std::string&
88372
88373   return jresult;
88374 }
88375
88376
88377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
88378   void * jresult ;
88379   std::string *arg1 = 0 ;
88380   Dali::ImageDimensions arg2 ;
88381   Dali::ImageDimensions *argp2 ;
88382   Dali::PixelData result;
88383
88384   if (!jarg1) {
88385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
88386     return 0;
88387   }
88388   std::string arg1_str(jarg1);
88389   arg1 = &arg1_str;
88390   argp2 = (Dali::ImageDimensions *)jarg2;
88391   if (!argp2) {
88392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
88393     return 0;
88394   }
88395   arg2 = *argp2;
88396   {
88397     try {
88398       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
88399     } catch (std::out_of_range& e) {
88400       {
88401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88402       };
88403     } catch (std::exception& e) {
88404       {
88405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88406       };
88407     } catch (Dali::DaliException e) {
88408       {
88409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88410       };
88411     } catch (...) {
88412       {
88413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88414       };
88415     }
88416   }
88417
88418   jresult = new Dali::PixelData((const Dali::PixelData &)result);
88419
88420   //argout typemap for const std::string&
88421
88422   return jresult;
88423 }
88424
88425
88426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
88427   void * jresult ;
88428   std::string *arg1 = 0 ;
88429   Dali::ImageDimensions arg2 ;
88430   Dali::FittingMode::Type arg3 ;
88431   Dali::SamplingMode::Type arg4 ;
88432   bool arg5 ;
88433   Dali::ImageDimensions *argp2 ;
88434   Dali::PixelData result;
88435
88436   if (!jarg1) {
88437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
88438     return 0;
88439   }
88440   std::string arg1_str(jarg1);
88441   arg1 = &arg1_str;
88442   argp2 = (Dali::ImageDimensions *)jarg2;
88443   if (!argp2) {
88444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
88445     return 0;
88446   }
88447   arg2 = *argp2;
88448   arg3 = (Dali::FittingMode::Type)jarg3;
88449   arg4 = (Dali::SamplingMode::Type)jarg4;
88450   arg5 = jarg5 ? true : false;
88451   {
88452     try {
88453       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
88454     } catch (std::out_of_range& e) {
88455       {
88456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88457       };
88458     } catch (std::exception& e) {
88459       {
88460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88461       };
88462     } catch (Dali::DaliException e) {
88463       {
88464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88465       };
88466     } catch (...) {
88467       {
88468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88469       };
88470     }
88471   }
88472
88473   jresult = new Dali::PixelData((const Dali::PixelData &)result);
88474
88475   //argout typemap for const std::string&
88476
88477   return jresult;
88478 }
88479
88480
88481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
88482   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
88483
88484   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
88485   {
88486     try {
88487       delete arg1;
88488     } catch (std::out_of_range& e) {
88489       {
88490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88491       };
88492     } catch (std::exception& e) {
88493       {
88494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88495       };
88496     } catch (Dali::DaliException e) {
88497       {
88498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88499       };
88500     } catch (...) {
88501       {
88502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88503       };
88504     }
88505   }
88506
88507 }
88508
88509
88510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
88511   void * jresult ;
88512   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
88513   Dali::Actor arg2 ;
88514   Dali::Actor arg3 ;
88515   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
88516   Dali::Actor *argp2 ;
88517   Dali::Actor *argp3 ;
88518   Dali::Actor result;
88519
88520   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
88521   argp2 = (Dali::Actor *)jarg2;
88522   if (!argp2) {
88523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88524     return 0;
88525   }
88526   arg2 = *argp2;
88527   argp3 = (Dali::Actor *)jarg3;
88528   if (!argp3) {
88529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88530     return 0;
88531   }
88532   arg3 = *argp3;
88533   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
88534   {
88535     try {
88536       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
88537     } catch (std::out_of_range& e) {
88538       {
88539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88540       };
88541     } catch (std::exception& e) {
88542       {
88543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88544       };
88545     } catch (Dali::DaliException e) {
88546       {
88547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88548       };
88549     } catch (...) {
88550       {
88551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88552       };
88553     }
88554   }
88555
88556   jresult = new Dali::Actor((const Dali::Actor &)result);
88557   return jresult;
88558 }
88559
88560
88561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
88562   void * jresult ;
88563   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
88564
88565   {
88566     try {
88567       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
88568     } catch (std::out_of_range& e) {
88569       {
88570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88571       };
88572     } catch (std::exception& e) {
88573       {
88574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88575       };
88576     } catch (Dali::DaliException e) {
88577       {
88578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88579       };
88580     } catch (...) {
88581       {
88582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88583       };
88584     }
88585   }
88586
88587   jresult = (void *)result;
88588   return jresult;
88589 }
88590
88591
88592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
88593   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
88594   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
88595   if (director) {
88596     director->swig_connect_director(callback0);
88597   }
88598 }
88599
88600
88601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
88602   KeyboardFocusManager arg1 ;
88603   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
88604   KeyboardFocusManager *argp1 ;
88605
88606   argp1 = (KeyboardFocusManager *)jarg1;
88607   if (!argp1) {
88608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
88609     return ;
88610   }
88611   arg1 = *argp1;
88612   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
88613   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
88614   {
88615     try {
88616       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
88617     } catch (std::out_of_range& e) {
88618       {
88619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88620       };
88621     } catch (std::exception& e) {
88622       {
88623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88624       };
88625     } catch (Dali::DaliException e) {
88626       {
88627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88628       };
88629     } catch (...) {
88630       {
88631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88632       };
88633     }
88634   }
88635
88636 }
88637
88638
88639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
88640   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88641
88642   arg1 = (std::vector< unsigned int > *)jarg1;
88643   {
88644     try {
88645       (arg1)->clear();
88646     } catch (std::out_of_range& e) {
88647       {
88648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88649       };
88650     } catch (std::exception& e) {
88651       {
88652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88653       };
88654     } catch (Dali::DaliException e) {
88655       {
88656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88657       };
88658     } catch (...) {
88659       {
88660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88661       };
88662     }
88663   }
88664
88665 }
88666
88667
88668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
88669   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88670   unsigned int *arg2 = 0 ;
88671   unsigned int temp2 ;
88672
88673   arg1 = (std::vector< unsigned int > *)jarg1;
88674   temp2 = (unsigned int)jarg2;
88675   arg2 = &temp2;
88676   {
88677     try {
88678       (arg1)->push_back((unsigned int const &)*arg2);
88679     } catch (std::out_of_range& e) {
88680       {
88681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88682       };
88683     } catch (std::exception& e) {
88684       {
88685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88686       };
88687     } catch (Dali::DaliException e) {
88688       {
88689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88690       };
88691     } catch (...) {
88692       {
88693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88694       };
88695     }
88696   }
88697
88698 }
88699
88700
88701 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
88702   unsigned long jresult ;
88703   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88704   std::vector< unsigned int >::size_type result;
88705
88706   arg1 = (std::vector< unsigned int > *)jarg1;
88707   {
88708     try {
88709       result = ((std::vector< unsigned int > const *)arg1)->size();
88710     } catch (std::out_of_range& e) {
88711       {
88712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88713       };
88714     } catch (std::exception& e) {
88715       {
88716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88717       };
88718     } catch (Dali::DaliException e) {
88719       {
88720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88721       };
88722     } catch (...) {
88723       {
88724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88725       };
88726     }
88727   }
88728
88729   jresult = (unsigned long)result;
88730   return jresult;
88731 }
88732
88733
88734 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
88735   unsigned long jresult ;
88736   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88737   std::vector< unsigned int >::size_type result;
88738
88739   arg1 = (std::vector< unsigned int > *)jarg1;
88740   {
88741     try {
88742       result = ((std::vector< unsigned int > const *)arg1)->capacity();
88743     } catch (std::out_of_range& e) {
88744       {
88745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88746       };
88747     } catch (std::exception& e) {
88748       {
88749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88750       };
88751     } catch (Dali::DaliException e) {
88752       {
88753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88754       };
88755     } catch (...) {
88756       {
88757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88758       };
88759     }
88760   }
88761
88762   jresult = (unsigned long)result;
88763   return jresult;
88764 }
88765
88766
88767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
88768   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88769   std::vector< unsigned int >::size_type arg2 ;
88770
88771   arg1 = (std::vector< unsigned int > *)jarg1;
88772   arg2 = (std::vector< unsigned int >::size_type)jarg2;
88773   {
88774     try {
88775       (arg1)->reserve(arg2);
88776     } catch (std::out_of_range& e) {
88777       {
88778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88779       };
88780     } catch (std::exception& e) {
88781       {
88782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88783       };
88784     } catch (Dali::DaliException e) {
88785       {
88786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88787       };
88788     } catch (...) {
88789       {
88790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88791       };
88792     }
88793   }
88794
88795 }
88796
88797
88798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
88799   void * jresult ;
88800   std::vector< unsigned int > *result = 0 ;
88801
88802   {
88803     try {
88804       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
88805     } catch (std::out_of_range& e) {
88806       {
88807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88808       };
88809     } catch (std::exception& e) {
88810       {
88811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88812       };
88813     } catch (Dali::DaliException e) {
88814       {
88815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88816       };
88817     } catch (...) {
88818       {
88819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88820       };
88821     }
88822   }
88823
88824   jresult = (void *)result;
88825   return jresult;
88826 }
88827
88828
88829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
88830   void * jresult ;
88831   std::vector< unsigned int > *arg1 = 0 ;
88832   std::vector< unsigned int > *result = 0 ;
88833
88834   arg1 = (std::vector< unsigned int > *)jarg1;
88835   if (!arg1) {
88836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
88837     return 0;
88838   }
88839   {
88840     try {
88841       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
88842     } catch (std::out_of_range& e) {
88843       {
88844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88845       };
88846     } catch (std::exception& e) {
88847       {
88848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88849       };
88850     } catch (Dali::DaliException e) {
88851       {
88852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88853       };
88854     } catch (...) {
88855       {
88856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88857       };
88858     }
88859   }
88860
88861   jresult = (void *)result;
88862   return jresult;
88863 }
88864
88865
88866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
88867   void * jresult ;
88868   int arg1 ;
88869   std::vector< unsigned int > *result = 0 ;
88870
88871   arg1 = (int)jarg1;
88872   {
88873     try {
88874       try {
88875         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
88876       }
88877       catch(std::out_of_range &_e) {
88878         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88879         return 0;
88880       }
88881
88882     } catch (std::out_of_range& e) {
88883       {
88884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88885       };
88886     } catch (std::exception& e) {
88887       {
88888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88889       };
88890     } catch (Dali::DaliException e) {
88891       {
88892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88893       };
88894     } catch (...) {
88895       {
88896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88897       };
88898     }
88899   }
88900
88901   jresult = (void *)result;
88902   return jresult;
88903 }
88904
88905
88906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
88907   unsigned int jresult ;
88908   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88909   int arg2 ;
88910   unsigned int result;
88911
88912   arg1 = (std::vector< unsigned int > *)jarg1;
88913   arg2 = (int)jarg2;
88914   {
88915     try {
88916       try {
88917         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
88918       }
88919       catch(std::out_of_range &_e) {
88920         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88921         return 0;
88922       }
88923
88924     } catch (std::out_of_range& e) {
88925       {
88926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88927       };
88928     } catch (std::exception& e) {
88929       {
88930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88931       };
88932     } catch (Dali::DaliException e) {
88933       {
88934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88935       };
88936     } catch (...) {
88937       {
88938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88939       };
88940     }
88941   }
88942
88943   jresult = result;
88944   return jresult;
88945 }
88946
88947
88948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
88949   unsigned int jresult ;
88950   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88951   int arg2 ;
88952   unsigned int *result = 0 ;
88953
88954   arg1 = (std::vector< unsigned int > *)jarg1;
88955   arg2 = (int)jarg2;
88956   {
88957     try {
88958       try {
88959         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
88960       }
88961       catch(std::out_of_range &_e) {
88962         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88963         return 0;
88964       }
88965
88966     } catch (std::out_of_range& e) {
88967       {
88968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88969       };
88970     } catch (std::exception& e) {
88971       {
88972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88973       };
88974     } catch (Dali::DaliException e) {
88975       {
88976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88977       };
88978     } catch (...) {
88979       {
88980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88981       };
88982     }
88983   }
88984
88985   jresult = *result;
88986   return jresult;
88987 }
88988
88989
88990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
88991   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88992   int arg2 ;
88993   unsigned int *arg3 = 0 ;
88994   unsigned int temp3 ;
88995
88996   arg1 = (std::vector< unsigned int > *)jarg1;
88997   arg2 = (int)jarg2;
88998   temp3 = (unsigned int)jarg3;
88999   arg3 = &temp3;
89000   {
89001     try {
89002       try {
89003         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
89004       }
89005       catch(std::out_of_range &_e) {
89006         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89007         return ;
89008       }
89009
89010     } catch (std::out_of_range& e) {
89011       {
89012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89013       };
89014     } catch (std::exception& e) {
89015       {
89016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89017       };
89018     } catch (Dali::DaliException e) {
89019       {
89020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89021       };
89022     } catch (...) {
89023       {
89024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89025       };
89026     }
89027   }
89028
89029 }
89030
89031
89032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
89033   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89034   std::vector< unsigned int > *arg2 = 0 ;
89035
89036   arg1 = (std::vector< unsigned int > *)jarg1;
89037   arg2 = (std::vector< unsigned int > *)jarg2;
89038   if (!arg2) {
89039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
89040     return ;
89041   }
89042   {
89043     try {
89044       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
89045     } catch (std::out_of_range& e) {
89046       {
89047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89048       };
89049     } catch (std::exception& e) {
89050       {
89051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89052       };
89053     } catch (Dali::DaliException e) {
89054       {
89055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89056       };
89057     } catch (...) {
89058       {
89059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89060       };
89061     }
89062   }
89063
89064 }
89065
89066
89067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89068   void * jresult ;
89069   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89070   int arg2 ;
89071   int arg3 ;
89072   std::vector< unsigned int > *result = 0 ;
89073
89074   arg1 = (std::vector< unsigned int > *)jarg1;
89075   arg2 = (int)jarg2;
89076   arg3 = (int)jarg3;
89077   {
89078     try {
89079       try {
89080         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
89081       }
89082       catch(std::out_of_range &_e) {
89083         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89084         return 0;
89085       }
89086       catch(std::invalid_argument &_e) {
89087         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89088         return 0;
89089       }
89090
89091     } catch (std::out_of_range& e) {
89092       {
89093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89094       };
89095     } catch (std::exception& e) {
89096       {
89097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89098       };
89099     } catch (Dali::DaliException e) {
89100       {
89101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89102       };
89103     } catch (...) {
89104       {
89105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89106       };
89107     }
89108   }
89109
89110   jresult = (void *)result;
89111   return jresult;
89112 }
89113
89114
89115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
89116   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89117   int arg2 ;
89118   unsigned int *arg3 = 0 ;
89119   unsigned int temp3 ;
89120
89121   arg1 = (std::vector< unsigned int > *)jarg1;
89122   arg2 = (int)jarg2;
89123   temp3 = (unsigned int)jarg3;
89124   arg3 = &temp3;
89125   {
89126     try {
89127       try {
89128         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
89129       }
89130       catch(std::out_of_range &_e) {
89131         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89132         return ;
89133       }
89134
89135     } catch (std::out_of_range& e) {
89136       {
89137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89138       };
89139     } catch (std::exception& e) {
89140       {
89141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89142       };
89143     } catch (Dali::DaliException e) {
89144       {
89145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89146       };
89147     } catch (...) {
89148       {
89149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89150       };
89151     }
89152   }
89153
89154 }
89155
89156
89157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89158   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89159   int arg2 ;
89160   std::vector< unsigned int > *arg3 = 0 ;
89161
89162   arg1 = (std::vector< unsigned int > *)jarg1;
89163   arg2 = (int)jarg2;
89164   arg3 = (std::vector< unsigned int > *)jarg3;
89165   if (!arg3) {
89166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
89167     return ;
89168   }
89169   {
89170     try {
89171       try {
89172         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
89173       }
89174       catch(std::out_of_range &_e) {
89175         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89176         return ;
89177       }
89178
89179     } catch (std::out_of_range& e) {
89180       {
89181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89182       };
89183     } catch (std::exception& e) {
89184       {
89185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89186       };
89187     } catch (Dali::DaliException e) {
89188       {
89189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89190       };
89191     } catch (...) {
89192       {
89193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89194       };
89195     }
89196   }
89197
89198 }
89199
89200
89201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
89202   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89203   int arg2 ;
89204
89205   arg1 = (std::vector< unsigned int > *)jarg1;
89206   arg2 = (int)jarg2;
89207   {
89208     try {
89209       try {
89210         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
89211       }
89212       catch(std::out_of_range &_e) {
89213         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89214         return ;
89215       }
89216
89217     } catch (std::out_of_range& e) {
89218       {
89219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89220       };
89221     } catch (std::exception& e) {
89222       {
89223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89224       };
89225     } catch (Dali::DaliException e) {
89226       {
89227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89228       };
89229     } catch (...) {
89230       {
89231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89232       };
89233     }
89234   }
89235
89236 }
89237
89238
89239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89240   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89241   int arg2 ;
89242   int arg3 ;
89243
89244   arg1 = (std::vector< unsigned int > *)jarg1;
89245   arg2 = (int)jarg2;
89246   arg3 = (int)jarg3;
89247   {
89248     try {
89249       try {
89250         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
89251       }
89252       catch(std::out_of_range &_e) {
89253         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89254         return ;
89255       }
89256       catch(std::invalid_argument &_e) {
89257         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89258         return ;
89259       }
89260
89261     } catch (std::out_of_range& e) {
89262       {
89263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89264       };
89265     } catch (std::exception& e) {
89266       {
89267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89268       };
89269     } catch (Dali::DaliException e) {
89270       {
89271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89272       };
89273     } catch (...) {
89274       {
89275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89276       };
89277     }
89278   }
89279
89280 }
89281
89282
89283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
89284   void * jresult ;
89285   unsigned int *arg1 = 0 ;
89286   int arg2 ;
89287   unsigned int temp1 ;
89288   std::vector< unsigned int > *result = 0 ;
89289
89290   temp1 = (unsigned int)jarg1;
89291   arg1 = &temp1;
89292   arg2 = (int)jarg2;
89293   {
89294     try {
89295       try {
89296         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
89297       }
89298       catch(std::out_of_range &_e) {
89299         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89300         return 0;
89301       }
89302
89303     } catch (std::out_of_range& e) {
89304       {
89305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89306       };
89307     } catch (std::exception& e) {
89308       {
89309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89310       };
89311     } catch (Dali::DaliException e) {
89312       {
89313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89314       };
89315     } catch (...) {
89316       {
89317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89318       };
89319     }
89320   }
89321
89322   jresult = (void *)result;
89323   return jresult;
89324 }
89325
89326
89327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
89328   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89329
89330   arg1 = (std::vector< unsigned int > *)jarg1;
89331   {
89332     try {
89333       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
89334     } catch (std::out_of_range& e) {
89335       {
89336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89337       };
89338     } catch (std::exception& e) {
89339       {
89340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89341       };
89342     } catch (Dali::DaliException e) {
89343       {
89344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89345       };
89346     } catch (...) {
89347       {
89348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89349       };
89350     }
89351   }
89352
89353 }
89354
89355
89356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89357   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89358   int arg2 ;
89359   int arg3 ;
89360
89361   arg1 = (std::vector< unsigned int > *)jarg1;
89362   arg2 = (int)jarg2;
89363   arg3 = (int)jarg3;
89364   {
89365     try {
89366       try {
89367         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89368       }
89369       catch(std::out_of_range &_e) {
89370         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89371         return ;
89372       }
89373       catch(std::invalid_argument &_e) {
89374         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89375         return ;
89376       }
89377
89378     } catch (std::out_of_range& e) {
89379       {
89380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89381       };
89382     } catch (std::exception& e) {
89383       {
89384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89385       };
89386     } catch (Dali::DaliException e) {
89387       {
89388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89389       };
89390     } catch (...) {
89391       {
89392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89393       };
89394     }
89395   }
89396
89397 }
89398
89399
89400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89401   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89402   int arg2 ;
89403   std::vector< unsigned int > *arg3 = 0 ;
89404
89405   arg1 = (std::vector< unsigned int > *)jarg1;
89406   arg2 = (int)jarg2;
89407   arg3 = (std::vector< unsigned int > *)jarg3;
89408   if (!arg3) {
89409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
89410     return ;
89411   }
89412   {
89413     try {
89414       try {
89415         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
89416       }
89417       catch(std::out_of_range &_e) {
89418         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89419         return ;
89420       }
89421
89422     } catch (std::out_of_range& e) {
89423       {
89424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89425       };
89426     } catch (std::exception& e) {
89427       {
89428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89429       };
89430     } catch (Dali::DaliException e) {
89431       {
89432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89433       };
89434     } catch (...) {
89435       {
89436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89437       };
89438     }
89439   }
89440
89441 }
89442
89443
89444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
89445   unsigned int jresult ;
89446   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89447   unsigned int *arg2 = 0 ;
89448   unsigned int temp2 ;
89449   bool result;
89450
89451   arg1 = (std::vector< unsigned int > *)jarg1;
89452   temp2 = (unsigned int)jarg2;
89453   arg2 = &temp2;
89454   {
89455     try {
89456       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
89457     } catch (std::out_of_range& e) {
89458       {
89459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89460       };
89461     } catch (std::exception& e) {
89462       {
89463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89464       };
89465     } catch (Dali::DaliException e) {
89466       {
89467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89468       };
89469     } catch (...) {
89470       {
89471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89472       };
89473     }
89474   }
89475
89476   jresult = result;
89477   return jresult;
89478 }
89479
89480
89481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
89482   int jresult ;
89483   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89484   unsigned int *arg2 = 0 ;
89485   unsigned int temp2 ;
89486   int result;
89487
89488   arg1 = (std::vector< unsigned int > *)jarg1;
89489   temp2 = (unsigned int)jarg2;
89490   arg2 = &temp2;
89491   {
89492     try {
89493       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
89494     } catch (std::out_of_range& e) {
89495       {
89496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89497       };
89498     } catch (std::exception& e) {
89499       {
89500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89501       };
89502     } catch (Dali::DaliException e) {
89503       {
89504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89505       };
89506     } catch (...) {
89507       {
89508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89509       };
89510     }
89511   }
89512
89513   jresult = result;
89514   return jresult;
89515 }
89516
89517
89518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
89519   int jresult ;
89520   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89521   unsigned int *arg2 = 0 ;
89522   unsigned int temp2 ;
89523   int result;
89524
89525   arg1 = (std::vector< unsigned int > *)jarg1;
89526   temp2 = (unsigned int)jarg2;
89527   arg2 = &temp2;
89528   {
89529     try {
89530       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
89531     } catch (std::out_of_range& e) {
89532       {
89533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89534       };
89535     } catch (std::exception& e) {
89536       {
89537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89538       };
89539     } catch (Dali::DaliException e) {
89540       {
89541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89542       };
89543     } catch (...) {
89544       {
89545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89546       };
89547     }
89548   }
89549
89550   jresult = result;
89551   return jresult;
89552 }
89553
89554
89555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
89556   unsigned int jresult ;
89557   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89558   unsigned int *arg2 = 0 ;
89559   unsigned int temp2 ;
89560   bool result;
89561
89562   arg1 = (std::vector< unsigned int > *)jarg1;
89563   temp2 = (unsigned int)jarg2;
89564   arg2 = &temp2;
89565   {
89566     try {
89567       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
89568     } catch (std::out_of_range& e) {
89569       {
89570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89571       };
89572     } catch (std::exception& e) {
89573       {
89574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89575       };
89576     } catch (Dali::DaliException e) {
89577       {
89578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89579       };
89580     } catch (...) {
89581       {
89582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89583       };
89584     }
89585   }
89586
89587   jresult = result;
89588   return jresult;
89589 }
89590
89591
89592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
89593   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89594
89595   arg1 = (std::vector< unsigned int > *)jarg1;
89596   {
89597     try {
89598       delete arg1;
89599     } catch (std::out_of_range& e) {
89600       {
89601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89602       };
89603     } catch (std::exception& e) {
89604       {
89605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89606       };
89607     } catch (Dali::DaliException e) {
89608       {
89609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89610       };
89611     } catch (...) {
89612       {
89613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89614       };
89615     }
89616   }
89617
89618 }
89619
89620
89621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
89622   void * jresult ;
89623   std::pair< unsigned int,Dali::Actor > *result = 0 ;
89624
89625   {
89626     try {
89627       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
89628     } catch (std::out_of_range& e) {
89629       {
89630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89631       };
89632     } catch (std::exception& e) {
89633       {
89634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89635       };
89636     } catch (Dali::DaliException e) {
89637       {
89638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89639       };
89640     } catch (...) {
89641       {
89642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89643       };
89644     }
89645   }
89646
89647   jresult = (void *)result;
89648   return jresult;
89649 }
89650
89651
89652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
89653   void * jresult ;
89654   unsigned int arg1 ;
89655   Dali::Actor arg2 ;
89656   Dali::Actor *argp2 ;
89657   std::pair< unsigned int,Dali::Actor > *result = 0 ;
89658
89659   arg1 = (unsigned int)jarg1;
89660   argp2 = (Dali::Actor *)jarg2;
89661   if (!argp2) {
89662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89663     return 0;
89664   }
89665   arg2 = *argp2;
89666   {
89667     try {
89668       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
89669     } catch (std::out_of_range& e) {
89670       {
89671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89672       };
89673     } catch (std::exception& e) {
89674       {
89675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89676       };
89677     } catch (Dali::DaliException e) {
89678       {
89679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89680       };
89681     } catch (...) {
89682       {
89683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89684       };
89685     }
89686   }
89687
89688   jresult = (void *)result;
89689   return jresult;
89690 }
89691
89692
89693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
89694   void * jresult ;
89695   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
89696   std::pair< unsigned int,Dali::Actor > *result = 0 ;
89697
89698   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
89699   if (!arg1) {
89700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89701     return 0;
89702   }
89703   {
89704     try {
89705       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
89706     } catch (std::out_of_range& e) {
89707       {
89708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89709       };
89710     } catch (std::exception& e) {
89711       {
89712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89713       };
89714     } catch (Dali::DaliException e) {
89715       {
89716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89717       };
89718     } catch (...) {
89719       {
89720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89721       };
89722     }
89723   }
89724
89725   jresult = (void *)result;
89726   return jresult;
89727 }
89728
89729
89730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
89731   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
89732   unsigned int arg2 ;
89733
89734   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
89735   arg2 = (unsigned int)jarg2;
89736   if (arg1) (arg1)->first = arg2;
89737 }
89738
89739
89740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
89741   unsigned int jresult ;
89742   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
89743   unsigned int result;
89744
89745   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
89746   result = (unsigned int) ((arg1)->first);
89747   jresult = result;
89748   return jresult;
89749 }
89750
89751
89752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
89753   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
89754   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
89755
89756   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
89757   arg2 = (Dali::Actor *)jarg2;
89758   if (arg1) (arg1)->second = *arg2;
89759 }
89760
89761
89762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
89763   void * jresult ;
89764   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
89765   Dali::Actor *result = 0 ;
89766
89767   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
89768   result = (Dali::Actor *)& ((arg1)->second);
89769   jresult = (void *)result;
89770   return jresult;
89771 }
89772
89773
89774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
89775   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
89776
89777   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
89778   {
89779     try {
89780       delete arg1;
89781     } catch (std::out_of_range& e) {
89782       {
89783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89784       };
89785     } catch (std::exception& e) {
89786       {
89787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89788       };
89789     } catch (Dali::DaliException e) {
89790       {
89791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89792       };
89793     } catch (...) {
89794       {
89795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89796       };
89797     }
89798   }
89799
89800 }
89801
89802
89803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
89804   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89805
89806   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89807   {
89808     try {
89809       (arg1)->clear();
89810     } catch (std::out_of_range& e) {
89811       {
89812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89813       };
89814     } catch (std::exception& e) {
89815       {
89816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89817       };
89818     } catch (Dali::DaliException e) {
89819       {
89820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89821       };
89822     } catch (...) {
89823       {
89824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89825       };
89826     }
89827   }
89828
89829 }
89830
89831
89832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
89833   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89834   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
89835
89836   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89837   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
89838   if (!arg2) {
89839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89840     return ;
89841   }
89842   {
89843     try {
89844       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
89845     } catch (std::out_of_range& e) {
89846       {
89847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89848       };
89849     } catch (std::exception& e) {
89850       {
89851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89852       };
89853     } catch (Dali::DaliException e) {
89854       {
89855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89856       };
89857     } catch (...) {
89858       {
89859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89860       };
89861     }
89862   }
89863
89864 }
89865
89866
89867 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
89868   unsigned long jresult ;
89869   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89870   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
89871
89872   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89873   {
89874     try {
89875       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
89876     } catch (std::out_of_range& e) {
89877       {
89878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89879       };
89880     } catch (std::exception& e) {
89881       {
89882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89883       };
89884     } catch (Dali::DaliException e) {
89885       {
89886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89887       };
89888     } catch (...) {
89889       {
89890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89891       };
89892     }
89893   }
89894
89895   jresult = (unsigned long)result;
89896   return jresult;
89897 }
89898
89899
89900 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
89901   unsigned long jresult ;
89902   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89903   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
89904
89905   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89906   {
89907     try {
89908       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
89909     } catch (std::out_of_range& e) {
89910       {
89911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89912       };
89913     } catch (std::exception& e) {
89914       {
89915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89916       };
89917     } catch (Dali::DaliException e) {
89918       {
89919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89920       };
89921     } catch (...) {
89922       {
89923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89924       };
89925     }
89926   }
89927
89928   jresult = (unsigned long)result;
89929   return jresult;
89930 }
89931
89932
89933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
89934   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89935   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
89936
89937   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89938   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
89939   {
89940     try {
89941       (arg1)->reserve(arg2);
89942     } catch (std::out_of_range& e) {
89943       {
89944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89945       };
89946     } catch (std::exception& e) {
89947       {
89948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89949       };
89950     } catch (Dali::DaliException e) {
89951       {
89952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89953       };
89954     } catch (...) {
89955       {
89956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89957       };
89958     }
89959   }
89960
89961 }
89962
89963
89964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
89965   void * jresult ;
89966   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89967
89968   {
89969     try {
89970       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
89971     } catch (std::out_of_range& e) {
89972       {
89973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89974       };
89975     } catch (std::exception& e) {
89976       {
89977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89978       };
89979     } catch (Dali::DaliException e) {
89980       {
89981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89982       };
89983     } catch (...) {
89984       {
89985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89986       };
89987     }
89988   }
89989
89990   jresult = (void *)result;
89991   return jresult;
89992 }
89993
89994
89995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
89996   void * jresult ;
89997   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
89998   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89999
90000   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90001   if (!arg1) {
90002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
90003     return 0;
90004   }
90005   {
90006     try {
90007       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);
90008     } catch (std::out_of_range& e) {
90009       {
90010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90011       };
90012     } catch (std::exception& e) {
90013       {
90014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90015       };
90016     } catch (Dali::DaliException e) {
90017       {
90018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90019       };
90020     } catch (...) {
90021       {
90022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90023       };
90024     }
90025   }
90026
90027   jresult = (void *)result;
90028   return jresult;
90029 }
90030
90031
90032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
90033   void * jresult ;
90034   int arg1 ;
90035   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
90036
90037   arg1 = (int)jarg1;
90038   {
90039     try {
90040       try {
90041         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);
90042       }
90043       catch(std::out_of_range &_e) {
90044         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90045         return 0;
90046       }
90047
90048     } catch (std::out_of_range& e) {
90049       {
90050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90051       };
90052     } catch (std::exception& e) {
90053       {
90054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90055       };
90056     } catch (Dali::DaliException e) {
90057       {
90058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90059       };
90060     } catch (...) {
90061       {
90062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90063       };
90064     }
90065   }
90066
90067   jresult = (void *)result;
90068   return jresult;
90069 }
90070
90071
90072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
90073   void * jresult ;
90074   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90075   int arg2 ;
90076   std::pair< unsigned int,Dali::Actor > result;
90077
90078   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90079   arg2 = (int)jarg2;
90080   {
90081     try {
90082       try {
90083         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
90084       }
90085       catch(std::out_of_range &_e) {
90086         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90087         return 0;
90088       }
90089
90090     } catch (std::out_of_range& e) {
90091       {
90092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90093       };
90094     } catch (std::exception& e) {
90095       {
90096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90097       };
90098     } catch (Dali::DaliException e) {
90099       {
90100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90101       };
90102     } catch (...) {
90103       {
90104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90105       };
90106     }
90107   }
90108
90109   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
90110   return jresult;
90111 }
90112
90113
90114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
90115   void * jresult ;
90116   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90117   int arg2 ;
90118   std::pair< unsigned int,Dali::Actor > *result = 0 ;
90119
90120   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90121   arg2 = (int)jarg2;
90122   {
90123     try {
90124       try {
90125         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
90126       }
90127       catch(std::out_of_range &_e) {
90128         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90129         return 0;
90130       }
90131
90132     } catch (std::out_of_range& e) {
90133       {
90134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90135       };
90136     } catch (std::exception& e) {
90137       {
90138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90139       };
90140     } catch (Dali::DaliException e) {
90141       {
90142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90143       };
90144     } catch (...) {
90145       {
90146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90147       };
90148     }
90149   }
90150
90151   jresult = (void *)result;
90152   return jresult;
90153 }
90154
90155
90156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
90157   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90158   int arg2 ;
90159   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
90160
90161   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90162   arg2 = (int)jarg2;
90163   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
90164   if (!arg3) {
90165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
90166     return ;
90167   }
90168   {
90169     try {
90170       try {
90171         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);
90172       }
90173       catch(std::out_of_range &_e) {
90174         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90175         return ;
90176       }
90177
90178     } catch (std::out_of_range& e) {
90179       {
90180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90181       };
90182     } catch (std::exception& e) {
90183       {
90184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90185       };
90186     } catch (Dali::DaliException e) {
90187       {
90188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90189       };
90190     } catch (...) {
90191       {
90192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90193       };
90194     }
90195   }
90196
90197 }
90198
90199
90200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
90201   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90202   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
90203
90204   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90205   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
90206   if (!arg2) {
90207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
90208     return ;
90209   }
90210   {
90211     try {
90212       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);
90213     } catch (std::out_of_range& e) {
90214       {
90215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90216       };
90217     } catch (std::exception& e) {
90218       {
90219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90220       };
90221     } catch (Dali::DaliException e) {
90222       {
90223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90224       };
90225     } catch (...) {
90226       {
90227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90228       };
90229     }
90230   }
90231
90232 }
90233
90234
90235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
90236   void * jresult ;
90237   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90238   int arg2 ;
90239   int arg3 ;
90240   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
90241
90242   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90243   arg2 = (int)jarg2;
90244   arg3 = (int)jarg3;
90245   {
90246     try {
90247       try {
90248         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);
90249       }
90250       catch(std::out_of_range &_e) {
90251         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90252         return 0;
90253       }
90254       catch(std::invalid_argument &_e) {
90255         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90256         return 0;
90257       }
90258
90259     } catch (std::out_of_range& e) {
90260       {
90261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90262       };
90263     } catch (std::exception& e) {
90264       {
90265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90266       };
90267     } catch (Dali::DaliException e) {
90268       {
90269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90270       };
90271     } catch (...) {
90272       {
90273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90274       };
90275     }
90276   }
90277
90278   jresult = (void *)result;
90279   return jresult;
90280 }
90281
90282
90283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
90284   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90285   int arg2 ;
90286   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
90287
90288   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90289   arg2 = (int)jarg2;
90290   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
90291   if (!arg3) {
90292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
90293     return ;
90294   }
90295   {
90296     try {
90297       try {
90298         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);
90299       }
90300       catch(std::out_of_range &_e) {
90301         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90302         return ;
90303       }
90304
90305     } catch (std::out_of_range& e) {
90306       {
90307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90308       };
90309     } catch (std::exception& e) {
90310       {
90311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90312       };
90313     } catch (Dali::DaliException e) {
90314       {
90315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90316       };
90317     } catch (...) {
90318       {
90319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90320       };
90321     }
90322   }
90323
90324 }
90325
90326
90327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
90328   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90329   int arg2 ;
90330   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
90331
90332   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90333   arg2 = (int)jarg2;
90334   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
90335   if (!arg3) {
90336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
90337     return ;
90338   }
90339   {
90340     try {
90341       try {
90342         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);
90343       }
90344       catch(std::out_of_range &_e) {
90345         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90346         return ;
90347       }
90348
90349     } catch (std::out_of_range& e) {
90350       {
90351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90352       };
90353     } catch (std::exception& e) {
90354       {
90355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90356       };
90357     } catch (Dali::DaliException e) {
90358       {
90359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90360       };
90361     } catch (...) {
90362       {
90363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90364       };
90365     }
90366   }
90367
90368 }
90369
90370
90371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
90372   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90373   int arg2 ;
90374
90375   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90376   arg2 = (int)jarg2;
90377   {
90378     try {
90379       try {
90380         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
90381       }
90382       catch(std::out_of_range &_e) {
90383         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90384         return ;
90385       }
90386
90387     } catch (std::out_of_range& e) {
90388       {
90389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90390       };
90391     } catch (std::exception& e) {
90392       {
90393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90394       };
90395     } catch (Dali::DaliException e) {
90396       {
90397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90398       };
90399     } catch (...) {
90400       {
90401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90402       };
90403     }
90404   }
90405
90406 }
90407
90408
90409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
90410   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90411   int arg2 ;
90412   int arg3 ;
90413
90414   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90415   arg2 = (int)jarg2;
90416   arg3 = (int)jarg3;
90417   {
90418     try {
90419       try {
90420         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
90421       }
90422       catch(std::out_of_range &_e) {
90423         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90424         return ;
90425       }
90426       catch(std::invalid_argument &_e) {
90427         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90428         return ;
90429       }
90430
90431     } catch (std::out_of_range& e) {
90432       {
90433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90434       };
90435     } catch (std::exception& e) {
90436       {
90437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90438       };
90439     } catch (Dali::DaliException e) {
90440       {
90441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90442       };
90443     } catch (...) {
90444       {
90445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90446       };
90447     }
90448   }
90449
90450 }
90451
90452
90453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
90454   void * jresult ;
90455   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
90456   int arg2 ;
90457   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
90458
90459   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
90460   if (!arg1) {
90461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
90462     return 0;
90463   }
90464   arg2 = (int)jarg2;
90465   {
90466     try {
90467       try {
90468         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);
90469       }
90470       catch(std::out_of_range &_e) {
90471         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90472         return 0;
90473       }
90474
90475     } catch (std::out_of_range& e) {
90476       {
90477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90478       };
90479     } catch (std::exception& e) {
90480       {
90481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90482       };
90483     } catch (Dali::DaliException e) {
90484       {
90485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90486       };
90487     } catch (...) {
90488       {
90489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90490       };
90491     }
90492   }
90493
90494   jresult = (void *)result;
90495   return jresult;
90496 }
90497
90498
90499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
90500   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90501
90502   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90503   {
90504     try {
90505       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
90506     } catch (std::out_of_range& e) {
90507       {
90508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90509       };
90510     } catch (std::exception& e) {
90511       {
90512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90513       };
90514     } catch (Dali::DaliException e) {
90515       {
90516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90517       };
90518     } catch (...) {
90519       {
90520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90521       };
90522     }
90523   }
90524
90525 }
90526
90527
90528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
90529   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90530   int arg2 ;
90531   int arg3 ;
90532
90533   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90534   arg2 = (int)jarg2;
90535   arg3 = (int)jarg3;
90536   {
90537     try {
90538       try {
90539         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
90540       }
90541       catch(std::out_of_range &_e) {
90542         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90543         return ;
90544       }
90545       catch(std::invalid_argument &_e) {
90546         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90547         return ;
90548       }
90549
90550     } catch (std::out_of_range& e) {
90551       {
90552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90553       };
90554     } catch (std::exception& e) {
90555       {
90556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90557       };
90558     } catch (Dali::DaliException e) {
90559       {
90560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90561       };
90562     } catch (...) {
90563       {
90564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90565       };
90566     }
90567   }
90568
90569 }
90570
90571
90572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
90573   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90574   int arg2 ;
90575   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
90576
90577   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90578   arg2 = (int)jarg2;
90579   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
90580   if (!arg3) {
90581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
90582     return ;
90583   }
90584   {
90585     try {
90586       try {
90587         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);
90588       }
90589       catch(std::out_of_range &_e) {
90590         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90591         return ;
90592       }
90593
90594     } catch (std::out_of_range& e) {
90595       {
90596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90597       };
90598     } catch (std::exception& e) {
90599       {
90600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90601       };
90602     } catch (Dali::DaliException e) {
90603       {
90604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90605       };
90606     } catch (...) {
90607       {
90608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90609       };
90610     }
90611   }
90612
90613 }
90614
90615
90616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
90617   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90618
90619   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90620   {
90621     try {
90622       delete arg1;
90623     } catch (std::out_of_range& e) {
90624       {
90625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90626       };
90627     } catch (std::exception& e) {
90628       {
90629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90630       };
90631     } catch (Dali::DaliException e) {
90632       {
90633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90634       };
90635     } catch (...) {
90636       {
90637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90638       };
90639     }
90640   }
90641
90642 }
90643
90644
90645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
90646   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90647
90648   arg1 = (std::vector< Dali::Actor > *)jarg1;
90649   {
90650     try {
90651       (arg1)->clear();
90652     } catch (std::out_of_range& e) {
90653       {
90654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90655       };
90656     } catch (std::exception& e) {
90657       {
90658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90659       };
90660     } catch (Dali::DaliException e) {
90661       {
90662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90663       };
90664     } catch (...) {
90665       {
90666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90667       };
90668     }
90669   }
90670
90671 }
90672
90673
90674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
90675   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90676   Dali::Actor *arg2 = 0 ;
90677
90678   arg1 = (std::vector< Dali::Actor > *)jarg1;
90679   arg2 = (Dali::Actor *)jarg2;
90680   if (!arg2) {
90681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
90682     return ;
90683   }
90684   {
90685     try {
90686       (arg1)->push_back((Dali::Actor const &)*arg2);
90687     } catch (std::out_of_range& e) {
90688       {
90689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90690       };
90691     } catch (std::exception& e) {
90692       {
90693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90694       };
90695     } catch (Dali::DaliException e) {
90696       {
90697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90698       };
90699     } catch (...) {
90700       {
90701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90702       };
90703     }
90704   }
90705
90706 }
90707
90708
90709 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
90710   unsigned long jresult ;
90711   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90712   std::vector< Dali::Actor >::size_type result;
90713
90714   arg1 = (std::vector< Dali::Actor > *)jarg1;
90715   {
90716     try {
90717       result = ((std::vector< Dali::Actor > const *)arg1)->size();
90718     } catch (std::out_of_range& e) {
90719       {
90720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90721       };
90722     } catch (std::exception& e) {
90723       {
90724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90725       };
90726     } catch (Dali::DaliException e) {
90727       {
90728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90729       };
90730     } catch (...) {
90731       {
90732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90733       };
90734     }
90735   }
90736
90737   jresult = (unsigned long)result;
90738   return jresult;
90739 }
90740
90741
90742 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
90743   unsigned long jresult ;
90744   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90745   std::vector< Dali::Actor >::size_type result;
90746
90747   arg1 = (std::vector< Dali::Actor > *)jarg1;
90748   {
90749     try {
90750       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
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 = (unsigned long)result;
90771   return jresult;
90772 }
90773
90774
90775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
90776   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90777   std::vector< Dali::Actor >::size_type arg2 ;
90778
90779   arg1 = (std::vector< Dali::Actor > *)jarg1;
90780   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
90781   {
90782     try {
90783       (arg1)->reserve(arg2);
90784     } catch (std::out_of_range& e) {
90785       {
90786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90787       };
90788     } catch (std::exception& e) {
90789       {
90790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90791       };
90792     } catch (Dali::DaliException e) {
90793       {
90794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90795       };
90796     } catch (...) {
90797       {
90798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90799       };
90800     }
90801   }
90802
90803 }
90804
90805
90806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
90807   void * jresult ;
90808   std::vector< Dali::Actor > *result = 0 ;
90809
90810   {
90811     try {
90812       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
90813     } catch (std::out_of_range& e) {
90814       {
90815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90816       };
90817     } catch (std::exception& e) {
90818       {
90819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90820       };
90821     } catch (Dali::DaliException e) {
90822       {
90823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90824       };
90825     } catch (...) {
90826       {
90827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90828       };
90829     }
90830   }
90831
90832   jresult = (void *)result;
90833   return jresult;
90834 }
90835
90836
90837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
90838   void * jresult ;
90839   std::vector< Dali::Actor > *arg1 = 0 ;
90840   std::vector< Dali::Actor > *result = 0 ;
90841
90842   arg1 = (std::vector< Dali::Actor > *)jarg1;
90843   if (!arg1) {
90844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
90845     return 0;
90846   }
90847   {
90848     try {
90849       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
90850     } catch (std::out_of_range& e) {
90851       {
90852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90853       };
90854     } catch (std::exception& e) {
90855       {
90856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90857       };
90858     } catch (Dali::DaliException e) {
90859       {
90860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90861       };
90862     } catch (...) {
90863       {
90864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90865       };
90866     }
90867   }
90868
90869   jresult = (void *)result;
90870   return jresult;
90871 }
90872
90873
90874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
90875   void * jresult ;
90876   int arg1 ;
90877   std::vector< Dali::Actor > *result = 0 ;
90878
90879   arg1 = (int)jarg1;
90880   {
90881     try {
90882       try {
90883         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
90884       }
90885       catch(std::out_of_range &_e) {
90886         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90887         return 0;
90888       }
90889
90890     } catch (std::out_of_range& e) {
90891       {
90892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90893       };
90894     } catch (std::exception& e) {
90895       {
90896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90897       };
90898     } catch (Dali::DaliException e) {
90899       {
90900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90901       };
90902     } catch (...) {
90903       {
90904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90905       };
90906     }
90907   }
90908
90909   jresult = (void *)result;
90910   return jresult;
90911 }
90912
90913
90914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
90915   void * jresult ;
90916   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90917   int arg2 ;
90918   Dali::Actor result;
90919
90920   arg1 = (std::vector< Dali::Actor > *)jarg1;
90921   arg2 = (int)jarg2;
90922   {
90923     try {
90924       try {
90925         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
90926       }
90927       catch(std::out_of_range &_e) {
90928         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90929         return 0;
90930       }
90931
90932     } catch (std::out_of_range& e) {
90933       {
90934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90935       };
90936     } catch (std::exception& e) {
90937       {
90938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90939       };
90940     } catch (Dali::DaliException e) {
90941       {
90942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90943       };
90944     } catch (...) {
90945       {
90946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90947       };
90948     }
90949   }
90950
90951   jresult = new Dali::Actor((const Dali::Actor &)result);
90952   return jresult;
90953 }
90954
90955
90956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
90957   void * jresult ;
90958   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90959   int arg2 ;
90960   Dali::Actor *result = 0 ;
90961
90962   arg1 = (std::vector< Dali::Actor > *)jarg1;
90963   arg2 = (int)jarg2;
90964   {
90965     try {
90966       try {
90967         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
90968       }
90969       catch(std::out_of_range &_e) {
90970         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90971         return 0;
90972       }
90973
90974     } catch (std::out_of_range& e) {
90975       {
90976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90977       };
90978     } catch (std::exception& e) {
90979       {
90980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90981       };
90982     } catch (Dali::DaliException e) {
90983       {
90984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90985       };
90986     } catch (...) {
90987       {
90988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90989       };
90990     }
90991   }
90992
90993   jresult = (void *)result;
90994   return jresult;
90995 }
90996
90997
90998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
90999   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91000   int arg2 ;
91001   Dali::Actor *arg3 = 0 ;
91002
91003   arg1 = (std::vector< Dali::Actor > *)jarg1;
91004   arg2 = (int)jarg2;
91005   arg3 = (Dali::Actor *)jarg3;
91006   if (!arg3) {
91007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
91008     return ;
91009   }
91010   {
91011     try {
91012       try {
91013         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
91014       }
91015       catch(std::out_of_range &_e) {
91016         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91017         return ;
91018       }
91019
91020     } catch (std::out_of_range& e) {
91021       {
91022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91023       };
91024     } catch (std::exception& e) {
91025       {
91026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91027       };
91028     } catch (Dali::DaliException e) {
91029       {
91030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91031       };
91032     } catch (...) {
91033       {
91034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91035       };
91036     }
91037   }
91038
91039 }
91040
91041
91042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
91043   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91044   std::vector< Dali::Actor > *arg2 = 0 ;
91045
91046   arg1 = (std::vector< Dali::Actor > *)jarg1;
91047   arg2 = (std::vector< Dali::Actor > *)jarg2;
91048   if (!arg2) {
91049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
91050     return ;
91051   }
91052   {
91053     try {
91054       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
91055     } catch (std::out_of_range& e) {
91056       {
91057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91058       };
91059     } catch (std::exception& e) {
91060       {
91061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91062       };
91063     } catch (Dali::DaliException e) {
91064       {
91065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91066       };
91067     } catch (...) {
91068       {
91069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91070       };
91071     }
91072   }
91073
91074 }
91075
91076
91077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
91078   void * jresult ;
91079   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91080   int arg2 ;
91081   int arg3 ;
91082   std::vector< Dali::Actor > *result = 0 ;
91083
91084   arg1 = (std::vector< Dali::Actor > *)jarg1;
91085   arg2 = (int)jarg2;
91086   arg3 = (int)jarg3;
91087   {
91088     try {
91089       try {
91090         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
91091       }
91092       catch(std::out_of_range &_e) {
91093         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91094         return 0;
91095       }
91096       catch(std::invalid_argument &_e) {
91097         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91098         return 0;
91099       }
91100
91101     } catch (std::out_of_range& e) {
91102       {
91103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91104       };
91105     } catch (std::exception& e) {
91106       {
91107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91108       };
91109     } catch (Dali::DaliException e) {
91110       {
91111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91112       };
91113     } catch (...) {
91114       {
91115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91116       };
91117     }
91118   }
91119
91120   jresult = (void *)result;
91121   return jresult;
91122 }
91123
91124
91125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
91126   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91127   int arg2 ;
91128   Dali::Actor *arg3 = 0 ;
91129
91130   arg1 = (std::vector< Dali::Actor > *)jarg1;
91131   arg2 = (int)jarg2;
91132   arg3 = (Dali::Actor *)jarg3;
91133   if (!arg3) {
91134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
91135     return ;
91136   }
91137   {
91138     try {
91139       try {
91140         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
91141       }
91142       catch(std::out_of_range &_e) {
91143         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91144         return ;
91145       }
91146
91147     } catch (std::out_of_range& e) {
91148       {
91149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91150       };
91151     } catch (std::exception& e) {
91152       {
91153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91154       };
91155     } catch (Dali::DaliException e) {
91156       {
91157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91158       };
91159     } catch (...) {
91160       {
91161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91162       };
91163     }
91164   }
91165
91166 }
91167
91168
91169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
91170   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91171   int arg2 ;
91172   std::vector< Dali::Actor > *arg3 = 0 ;
91173
91174   arg1 = (std::vector< Dali::Actor > *)jarg1;
91175   arg2 = (int)jarg2;
91176   arg3 = (std::vector< Dali::Actor > *)jarg3;
91177   if (!arg3) {
91178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
91179     return ;
91180   }
91181   {
91182     try {
91183       try {
91184         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
91185       }
91186       catch(std::out_of_range &_e) {
91187         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91188         return ;
91189       }
91190
91191     } catch (std::out_of_range& e) {
91192       {
91193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91194       };
91195     } catch (std::exception& e) {
91196       {
91197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91198       };
91199     } catch (Dali::DaliException e) {
91200       {
91201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91202       };
91203     } catch (...) {
91204       {
91205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91206       };
91207     }
91208   }
91209
91210 }
91211
91212
91213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
91214   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91215   int arg2 ;
91216
91217   arg1 = (std::vector< Dali::Actor > *)jarg1;
91218   arg2 = (int)jarg2;
91219   {
91220     try {
91221       try {
91222         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
91223       }
91224       catch(std::out_of_range &_e) {
91225         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91226         return ;
91227       }
91228
91229     } catch (std::out_of_range& e) {
91230       {
91231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91232       };
91233     } catch (std::exception& e) {
91234       {
91235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91236       };
91237     } catch (Dali::DaliException e) {
91238       {
91239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91240       };
91241     } catch (...) {
91242       {
91243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91244       };
91245     }
91246   }
91247
91248 }
91249
91250
91251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
91252   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91253   int arg2 ;
91254   int arg3 ;
91255
91256   arg1 = (std::vector< Dali::Actor > *)jarg1;
91257   arg2 = (int)jarg2;
91258   arg3 = (int)jarg3;
91259   {
91260     try {
91261       try {
91262         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
91263       }
91264       catch(std::out_of_range &_e) {
91265         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91266         return ;
91267       }
91268       catch(std::invalid_argument &_e) {
91269         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91270         return ;
91271       }
91272
91273     } catch (std::out_of_range& e) {
91274       {
91275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91276       };
91277     } catch (std::exception& e) {
91278       {
91279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91280       };
91281     } catch (Dali::DaliException e) {
91282       {
91283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91284       };
91285     } catch (...) {
91286       {
91287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91288       };
91289     }
91290   }
91291
91292 }
91293
91294
91295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
91296   void * jresult ;
91297   Dali::Actor *arg1 = 0 ;
91298   int arg2 ;
91299   std::vector< Dali::Actor > *result = 0 ;
91300
91301   arg1 = (Dali::Actor *)jarg1;
91302   if (!arg1) {
91303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
91304     return 0;
91305   }
91306   arg2 = (int)jarg2;
91307   {
91308     try {
91309       try {
91310         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
91311       }
91312       catch(std::out_of_range &_e) {
91313         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91314         return 0;
91315       }
91316
91317     } catch (std::out_of_range& e) {
91318       {
91319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91320       };
91321     } catch (std::exception& e) {
91322       {
91323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91324       };
91325     } catch (Dali::DaliException e) {
91326       {
91327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91328       };
91329     } catch (...) {
91330       {
91331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91332       };
91333     }
91334   }
91335
91336   jresult = (void *)result;
91337   return jresult;
91338 }
91339
91340
91341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
91342   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91343
91344   arg1 = (std::vector< Dali::Actor > *)jarg1;
91345   {
91346     try {
91347       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
91348     } catch (std::out_of_range& e) {
91349       {
91350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91351       };
91352     } catch (std::exception& e) {
91353       {
91354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91355       };
91356     } catch (Dali::DaliException e) {
91357       {
91358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91359       };
91360     } catch (...) {
91361       {
91362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91363       };
91364     }
91365   }
91366
91367 }
91368
91369
91370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
91371   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91372   int arg2 ;
91373   int arg3 ;
91374
91375   arg1 = (std::vector< Dali::Actor > *)jarg1;
91376   arg2 = (int)jarg2;
91377   arg3 = (int)jarg3;
91378   {
91379     try {
91380       try {
91381         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
91382       }
91383       catch(std::out_of_range &_e) {
91384         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91385         return ;
91386       }
91387       catch(std::invalid_argument &_e) {
91388         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91389         return ;
91390       }
91391
91392     } catch (std::out_of_range& e) {
91393       {
91394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91395       };
91396     } catch (std::exception& e) {
91397       {
91398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91399       };
91400     } catch (Dali::DaliException e) {
91401       {
91402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91403       };
91404     } catch (...) {
91405       {
91406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91407       };
91408     }
91409   }
91410
91411 }
91412
91413
91414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
91415   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91416   int arg2 ;
91417   std::vector< Dali::Actor > *arg3 = 0 ;
91418
91419   arg1 = (std::vector< Dali::Actor > *)jarg1;
91420   arg2 = (int)jarg2;
91421   arg3 = (std::vector< Dali::Actor > *)jarg3;
91422   if (!arg3) {
91423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
91424     return ;
91425   }
91426   {
91427     try {
91428       try {
91429         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
91430       }
91431       catch(std::out_of_range &_e) {
91432         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91433         return ;
91434       }
91435
91436     } catch (std::out_of_range& e) {
91437       {
91438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91439       };
91440     } catch (std::exception& e) {
91441       {
91442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91443       };
91444     } catch (Dali::DaliException e) {
91445       {
91446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91447       };
91448     } catch (...) {
91449       {
91450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91451       };
91452     }
91453   }
91454
91455 }
91456
91457
91458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
91459   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91460
91461   arg1 = (std::vector< Dali::Actor > *)jarg1;
91462   {
91463     try {
91464       delete arg1;
91465     } catch (std::out_of_range& e) {
91466       {
91467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91468       };
91469     } catch (std::exception& e) {
91470       {
91471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91472       };
91473     } catch (Dali::DaliException e) {
91474       {
91475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91476       };
91477     } catch (...) {
91478       {
91479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91480       };
91481     }
91482   }
91483
91484 }
91485
91486
91487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
91488   unsigned int jresult ;
91489   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
91490   bool result;
91491
91492   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
91493   {
91494     try {
91495       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
91496     } catch (std::out_of_range& e) {
91497       {
91498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91499       };
91500     } catch (std::exception& e) {
91501       {
91502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91503       };
91504     } catch (Dali::DaliException e) {
91505       {
91506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91507       };
91508     } catch (...) {
91509       {
91510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91511       };
91512     }
91513   }
91514
91515   jresult = result;
91516   return jresult;
91517 }
91518
91519
91520 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
91521   unsigned long jresult ;
91522   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
91523   std::size_t result;
91524
91525   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
91526   {
91527     try {
91528       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
91529     } catch (std::out_of_range& e) {
91530       {
91531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91532       };
91533     } catch (std::exception& e) {
91534       {
91535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91536       };
91537     } catch (Dali::DaliException e) {
91538       {
91539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91540       };
91541     } catch (...) {
91542       {
91543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91544       };
91545     }
91546   }
91547
91548   jresult = (unsigned long)result;
91549   return jresult;
91550 }
91551
91552
91553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
91554   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
91555   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
91556
91557   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
91558   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
91559   {
91560     try {
91561       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
91562     } catch (std::out_of_range& e) {
91563       {
91564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91565       };
91566     } catch (std::exception& e) {
91567       {
91568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91569       };
91570     } catch (Dali::DaliException e) {
91571       {
91572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91573       };
91574     } catch (...) {
91575       {
91576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91577       };
91578     }
91579   }
91580
91581 }
91582
91583
91584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
91585   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
91586   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
91587
91588   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
91589   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
91590   {
91591     try {
91592       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
91593     } catch (std::out_of_range& e) {
91594       {
91595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91596       };
91597     } catch (std::exception& e) {
91598       {
91599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91600       };
91601     } catch (Dali::DaliException e) {
91602       {
91603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91604       };
91605     } catch (...) {
91606       {
91607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91608       };
91609     }
91610   }
91611
91612 }
91613
91614
91615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
91616   unsigned int jresult ;
91617   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
91618   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
91619   bool result;
91620
91621   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
91622   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
91623   if (!arg2) {
91624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
91625     return 0;
91626   }
91627   {
91628     try {
91629       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
91630     } catch (std::out_of_range& e) {
91631       {
91632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91633       };
91634     } catch (std::exception& e) {
91635       {
91636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91637       };
91638     } catch (Dali::DaliException e) {
91639       {
91640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91641       };
91642     } catch (...) {
91643       {
91644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91645       };
91646     }
91647   }
91648
91649   jresult = result;
91650   return jresult;
91651 }
91652
91653
91654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
91655   void * jresult ;
91656   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
91657
91658   {
91659     try {
91660       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
91661     } catch (std::out_of_range& e) {
91662       {
91663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91664       };
91665     } catch (std::exception& e) {
91666       {
91667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91668       };
91669     } catch (Dali::DaliException e) {
91670       {
91671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91672       };
91673     } catch (...) {
91674       {
91675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91676       };
91677     }
91678   }
91679
91680   jresult = (void *)result;
91681   return jresult;
91682 }
91683
91684
91685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
91686   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
91687
91688   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
91689   {
91690     try {
91691       delete arg1;
91692     } catch (std::out_of_range& e) {
91693       {
91694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91695       };
91696     } catch (std::exception& e) {
91697       {
91698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91699       };
91700     } catch (Dali::DaliException e) {
91701       {
91702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91703       };
91704     } catch (...) {
91705       {
91706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91707       };
91708     }
91709   }
91710
91711 }
91712
91713
91714 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
91715   unsigned int jresult ;
91716   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
91717   bool result;
91718
91719   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
91720   {
91721     try {
91722       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);
91723     } catch (std::out_of_range& e) {
91724       {
91725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91726       };
91727     } catch (std::exception& e) {
91728       {
91729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91730       };
91731     } catch (Dali::DaliException e) {
91732       {
91733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91734       };
91735     } catch (...) {
91736       {
91737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91738       };
91739     }
91740   }
91741
91742   jresult = result;
91743   return jresult;
91744 }
91745
91746
91747 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
91748   unsigned long jresult ;
91749   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
91750   std::size_t result;
91751
91752   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
91753   {
91754     try {
91755       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);
91756     } catch (std::out_of_range& e) {
91757       {
91758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91759       };
91760     } catch (std::exception& e) {
91761       {
91762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91763       };
91764     } catch (Dali::DaliException e) {
91765       {
91766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91767       };
91768     } catch (...) {
91769       {
91770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91771       };
91772     }
91773   }
91774
91775   jresult = (unsigned long)result;
91776   return jresult;
91777 }
91778
91779
91780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
91781   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
91782   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
91783
91784   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
91785   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
91786   {
91787     try {
91788       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
91789     } catch (std::out_of_range& e) {
91790       {
91791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91792       };
91793     } catch (std::exception& e) {
91794       {
91795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91796       };
91797     } catch (Dali::DaliException e) {
91798       {
91799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91800       };
91801     } catch (...) {
91802       {
91803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91804       };
91805     }
91806   }
91807
91808 }
91809
91810
91811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
91812   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
91813   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
91814
91815   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
91816   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
91817   {
91818     try {
91819       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
91820     } catch (std::out_of_range& e) {
91821       {
91822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91823       };
91824     } catch (std::exception& e) {
91825       {
91826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91827       };
91828     } catch (Dali::DaliException e) {
91829       {
91830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91831       };
91832     } catch (...) {
91833       {
91834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91835       };
91836     }
91837   }
91838
91839 }
91840
91841
91842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91843   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
91844   Dali::Actor arg2 ;
91845   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
91846   Dali::Actor *argp2 ;
91847
91848   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
91849   argp2 = (Dali::Actor *)jarg2;
91850   if (!argp2) {
91851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91852     return ;
91853   }
91854   arg2 = *argp2;
91855   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
91856   {
91857     try {
91858       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
91859     } catch (std::out_of_range& e) {
91860       {
91861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91862       };
91863     } catch (std::exception& e) {
91864       {
91865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91866       };
91867     } catch (Dali::DaliException e) {
91868       {
91869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91870       };
91871     } catch (...) {
91872       {
91873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91874       };
91875     }
91876   }
91877
91878 }
91879
91880
91881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
91882   void * jresult ;
91883   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
91884
91885   {
91886     try {
91887       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
91888     } catch (std::out_of_range& e) {
91889       {
91890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91891       };
91892     } catch (std::exception& e) {
91893       {
91894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91895       };
91896     } catch (Dali::DaliException e) {
91897       {
91898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91899       };
91900     } catch (...) {
91901       {
91902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91903       };
91904     }
91905   }
91906
91907   jresult = (void *)result;
91908   return jresult;
91909 }
91910
91911
91912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
91913   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
91914
91915   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
91916   {
91917     try {
91918       delete arg1;
91919     } catch (std::out_of_range& e) {
91920       {
91921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91922       };
91923     } catch (std::exception& e) {
91924       {
91925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91926       };
91927     } catch (Dali::DaliException e) {
91928       {
91929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91930       };
91931     } catch (...) {
91932       {
91933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91934       };
91935     }
91936   }
91937
91938 }
91939
91940
91941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
91942   unsigned int jresult ;
91943   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
91944   bool result;
91945
91946   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
91947   {
91948     try {
91949       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
91950     } catch (std::out_of_range& e) {
91951       {
91952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91953       };
91954     } catch (std::exception& e) {
91955       {
91956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91957       };
91958     } catch (Dali::DaliException e) {
91959       {
91960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91961       };
91962     } catch (...) {
91963       {
91964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91965       };
91966     }
91967   }
91968
91969   jresult = result;
91970   return jresult;
91971 }
91972
91973
91974 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
91975   unsigned long jresult ;
91976   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
91977   std::size_t result;
91978
91979   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
91980   {
91981     try {
91982       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
91983     } catch (std::out_of_range& e) {
91984       {
91985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91986       };
91987     } catch (std::exception& e) {
91988       {
91989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91990       };
91991     } catch (Dali::DaliException e) {
91992       {
91993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91994       };
91995     } catch (...) {
91996       {
91997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91998       };
91999     }
92000   }
92001
92002   jresult = (unsigned long)result;
92003   return jresult;
92004 }
92005
92006
92007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
92008   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
92009   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
92010
92011   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
92012   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
92013   {
92014     try {
92015       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
92016     } catch (std::out_of_range& e) {
92017       {
92018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92019       };
92020     } catch (std::exception& e) {
92021       {
92022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92023       };
92024     } catch (Dali::DaliException e) {
92025       {
92026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92027       };
92028     } catch (...) {
92029       {
92030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92031       };
92032     }
92033   }
92034
92035 }
92036
92037
92038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92039   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
92040   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
92041
92042   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
92043   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
92044   {
92045     try {
92046       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
92047     } catch (std::out_of_range& e) {
92048       {
92049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92050       };
92051     } catch (std::exception& e) {
92052       {
92053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92054       };
92055     } catch (Dali::DaliException e) {
92056       {
92057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92058       };
92059     } catch (...) {
92060       {
92061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92062       };
92063     }
92064   }
92065
92066 }
92067
92068
92069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
92070   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
92071   Dali::Actor arg2 ;
92072   Dali::Actor arg3 ;
92073   Dali::Actor *argp2 ;
92074   Dali::Actor *argp3 ;
92075
92076   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
92077   argp2 = (Dali::Actor *)jarg2;
92078   if (!argp2) {
92079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92080     return ;
92081   }
92082   arg2 = *argp2;
92083   argp3 = (Dali::Actor *)jarg3;
92084   if (!argp3) {
92085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92086     return ;
92087   }
92088   arg3 = *argp3;
92089   {
92090     try {
92091       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
92092     } catch (std::out_of_range& e) {
92093       {
92094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92095       };
92096     } catch (std::exception& e) {
92097       {
92098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92099       };
92100     } catch (Dali::DaliException e) {
92101       {
92102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92103       };
92104     } catch (...) {
92105       {
92106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92107       };
92108     }
92109   }
92110
92111 }
92112
92113
92114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
92115   void * jresult ;
92116   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
92117
92118   {
92119     try {
92120       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
92121     } catch (std::out_of_range& e) {
92122       {
92123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92124       };
92125     } catch (std::exception& e) {
92126       {
92127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92128       };
92129     } catch (Dali::DaliException e) {
92130       {
92131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92132       };
92133     } catch (...) {
92134       {
92135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92136       };
92137     }
92138   }
92139
92140   jresult = (void *)result;
92141   return jresult;
92142 }
92143
92144
92145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
92146   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
92147
92148   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
92149   {
92150     try {
92151       delete arg1;
92152     } catch (std::out_of_range& e) {
92153       {
92154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92155       };
92156     } catch (std::exception& e) {
92157       {
92158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92159       };
92160     } catch (Dali::DaliException e) {
92161       {
92162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92163       };
92164     } catch (...) {
92165       {
92166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92167       };
92168     }
92169   }
92170
92171 }
92172
92173
92174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
92175   unsigned int jresult ;
92176   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
92177   bool result;
92178
92179   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
92180   {
92181     try {
92182       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
92183     } catch (std::out_of_range& e) {
92184       {
92185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92186       };
92187     } catch (std::exception& e) {
92188       {
92189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92190       };
92191     } catch (Dali::DaliException e) {
92192       {
92193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92194       };
92195     } catch (...) {
92196       {
92197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92198       };
92199     }
92200   }
92201
92202   jresult = result;
92203   return jresult;
92204 }
92205
92206
92207 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
92208   unsigned long jresult ;
92209   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
92210   std::size_t result;
92211
92212   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
92213   {
92214     try {
92215       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
92216     } catch (std::out_of_range& e) {
92217       {
92218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92219       };
92220     } catch (std::exception& e) {
92221       {
92222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92223       };
92224     } catch (Dali::DaliException e) {
92225       {
92226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92227       };
92228     } catch (...) {
92229       {
92230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92231       };
92232     }
92233   }
92234
92235   jresult = (unsigned long)result;
92236   return jresult;
92237 }
92238
92239
92240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
92241   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
92242   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
92243
92244   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
92245   arg2 = (void (*)(Dali::Actor,bool))jarg2;
92246   {
92247     try {
92248       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
92249     } catch (std::out_of_range& e) {
92250       {
92251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92252       };
92253     } catch (std::exception& e) {
92254       {
92255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92256       };
92257     } catch (Dali::DaliException e) {
92258       {
92259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92260       };
92261     } catch (...) {
92262       {
92263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92264       };
92265     }
92266   }
92267
92268 }
92269
92270
92271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92272   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
92273   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
92274
92275   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
92276   arg2 = (void (*)(Dali::Actor,bool))jarg2;
92277   {
92278     try {
92279       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
92280     } catch (std::out_of_range& e) {
92281       {
92282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92283       };
92284     } catch (std::exception& e) {
92285       {
92286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92287       };
92288     } catch (Dali::DaliException e) {
92289       {
92290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92291       };
92292     } catch (...) {
92293       {
92294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92295       };
92296     }
92297   }
92298
92299 }
92300
92301
92302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
92303   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
92304   Dali::Actor arg2 ;
92305   bool arg3 ;
92306   Dali::Actor *argp2 ;
92307
92308   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
92309   argp2 = (Dali::Actor *)jarg2;
92310   if (!argp2) {
92311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92312     return ;
92313   }
92314   arg2 = *argp2;
92315   arg3 = jarg3 ? true : false;
92316   {
92317     try {
92318       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
92319     } catch (std::out_of_range& e) {
92320       {
92321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92322       };
92323     } catch (std::exception& e) {
92324       {
92325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92326       };
92327     } catch (Dali::DaliException e) {
92328       {
92329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92330       };
92331     } catch (...) {
92332       {
92333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92334       };
92335     }
92336   }
92337
92338 }
92339
92340
92341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
92342   void * jresult ;
92343   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
92344
92345   {
92346     try {
92347       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
92348     } catch (std::out_of_range& e) {
92349       {
92350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92351       };
92352     } catch (std::exception& e) {
92353       {
92354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92355       };
92356     } catch (Dali::DaliException e) {
92357       {
92358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92359       };
92360     } catch (...) {
92361       {
92362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92363       };
92364     }
92365   }
92366
92367   jresult = (void *)result;
92368   return jresult;
92369 }
92370
92371
92372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
92373   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
92374
92375   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
92376   {
92377     try {
92378       delete arg1;
92379     } catch (std::out_of_range& e) {
92380       {
92381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92382       };
92383     } catch (std::exception& e) {
92384       {
92385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92386       };
92387     } catch (Dali::DaliException e) {
92388       {
92389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92390       };
92391     } catch (...) {
92392       {
92393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92394       };
92395     }
92396   }
92397
92398 }
92399
92400
92401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
92402   unsigned int jresult ;
92403   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
92404   bool result;
92405
92406   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
92407   {
92408     try {
92409       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);
92410     } catch (std::out_of_range& e) {
92411       {
92412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92413       };
92414     } catch (std::exception& e) {
92415       {
92416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92417       };
92418     } catch (Dali::DaliException e) {
92419       {
92420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92421       };
92422     } catch (...) {
92423       {
92424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92425       };
92426     }
92427   }
92428
92429   jresult = result;
92430   return jresult;
92431 }
92432
92433
92434 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
92435   unsigned long jresult ;
92436   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
92437   std::size_t result;
92438
92439   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
92440   {
92441     try {
92442       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);
92443     } catch (std::out_of_range& e) {
92444       {
92445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92446       };
92447     } catch (std::exception& e) {
92448       {
92449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92450       };
92451     } catch (Dali::DaliException e) {
92452       {
92453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92454       };
92455     } catch (...) {
92456       {
92457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92458       };
92459     }
92460   }
92461
92462   jresult = (unsigned long)result;
92463   return jresult;
92464 }
92465
92466
92467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
92468   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
92469   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
92470
92471   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
92472   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
92473   {
92474     try {
92475       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
92476     } catch (std::out_of_range& e) {
92477       {
92478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92479       };
92480     } catch (std::exception& e) {
92481       {
92482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92483       };
92484     } catch (Dali::DaliException e) {
92485       {
92486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92487       };
92488     } catch (...) {
92489       {
92490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92491       };
92492     }
92493   }
92494
92495 }
92496
92497
92498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92499   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
92500   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
92501
92502   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
92503   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
92504   {
92505     try {
92506       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
92507     } catch (std::out_of_range& e) {
92508       {
92509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92510       };
92511     } catch (std::exception& e) {
92512       {
92513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92514       };
92515     } catch (Dali::DaliException e) {
92516       {
92517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92518       };
92519     } catch (...) {
92520       {
92521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92522       };
92523     }
92524   }
92525
92526 }
92527
92528
92529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
92530   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
92531   Dali::Toolkit::StyleManager arg2 ;
92532   Dali::StyleChange::Type arg3 ;
92533   Dali::Toolkit::StyleManager *argp2 ;
92534
92535   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
92536   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
92537   if (!argp2) {
92538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
92539     return ;
92540   }
92541   arg2 = *argp2;
92542   arg3 = (Dali::StyleChange::Type)jarg3;
92543   {
92544     try {
92545       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
92546     } catch (std::out_of_range& e) {
92547       {
92548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92549       };
92550     } catch (std::exception& e) {
92551       {
92552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92553       };
92554     } catch (Dali::DaliException e) {
92555       {
92556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92557       };
92558     } catch (...) {
92559       {
92560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92561       };
92562     }
92563   }
92564
92565 }
92566
92567
92568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
92569   void * jresult ;
92570   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
92571
92572   {
92573     try {
92574       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
92575     } catch (std::out_of_range& e) {
92576       {
92577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92578       };
92579     } catch (std::exception& e) {
92580       {
92581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92582       };
92583     } catch (Dali::DaliException e) {
92584       {
92585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92586       };
92587     } catch (...) {
92588       {
92589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92590       };
92591     }
92592   }
92593
92594   jresult = (void *)result;
92595   return jresult;
92596 }
92597
92598
92599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
92600   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
92601
92602   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
92603   {
92604     try {
92605       delete arg1;
92606     } catch (std::out_of_range& e) {
92607       {
92608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92609       };
92610     } catch (std::exception& e) {
92611       {
92612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92613       };
92614     } catch (Dali::DaliException e) {
92615       {
92616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92617       };
92618     } catch (...) {
92619       {
92620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92621       };
92622     }
92623   }
92624
92625 }
92626
92627
92628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
92629   unsigned int jresult ;
92630   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
92631   bool result;
92632
92633   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
92634   {
92635     try {
92636       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
92637     } catch (std::out_of_range& e) {
92638       {
92639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92640       };
92641     } catch (std::exception& e) {
92642       {
92643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92644       };
92645     } catch (Dali::DaliException e) {
92646       {
92647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92648       };
92649     } catch (...) {
92650       {
92651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92652       };
92653     }
92654   }
92655
92656   jresult = result;
92657   return jresult;
92658 }
92659
92660
92661 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
92662   unsigned long jresult ;
92663   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
92664   std::size_t result;
92665
92666   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
92667   {
92668     try {
92669       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
92670     } catch (std::out_of_range& e) {
92671       {
92672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92673       };
92674     } catch (std::exception& e) {
92675       {
92676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92677       };
92678     } catch (Dali::DaliException e) {
92679       {
92680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92681       };
92682     } catch (...) {
92683       {
92684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92685       };
92686     }
92687   }
92688
92689   jresult = (unsigned long)result;
92690   return jresult;
92691 }
92692
92693
92694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
92695   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
92696   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
92697
92698   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
92699   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
92700   {
92701     try {
92702       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
92703     } catch (std::out_of_range& e) {
92704       {
92705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92706       };
92707     } catch (std::exception& e) {
92708       {
92709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92710       };
92711     } catch (Dali::DaliException e) {
92712       {
92713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92714       };
92715     } catch (...) {
92716       {
92717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92718       };
92719     }
92720   }
92721
92722 }
92723
92724
92725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
92726   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
92727   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
92728
92729   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
92730   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
92731   {
92732     try {
92733       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
92734     } catch (std::out_of_range& e) {
92735       {
92736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92737       };
92738     } catch (std::exception& e) {
92739       {
92740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92741       };
92742     } catch (Dali::DaliException e) {
92743       {
92744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92745       };
92746     } catch (...) {
92747       {
92748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92749       };
92750     }
92751   }
92752
92753 }
92754
92755
92756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
92757   unsigned int jresult ;
92758   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
92759   Dali::Toolkit::Button arg2 ;
92760   Dali::Toolkit::Button *argp2 ;
92761   bool result;
92762
92763   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
92764   argp2 = (Dali::Toolkit::Button *)jarg2;
92765   if (!argp2) {
92766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
92767     return 0;
92768   }
92769   arg2 = *argp2;
92770   {
92771     try {
92772       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
92773     } catch (std::out_of_range& e) {
92774       {
92775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92776       };
92777     } catch (std::exception& e) {
92778       {
92779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92780       };
92781     } catch (Dali::DaliException e) {
92782       {
92783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92784       };
92785     } catch (...) {
92786       {
92787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92788       };
92789     }
92790   }
92791
92792   jresult = result;
92793   return jresult;
92794 }
92795
92796
92797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
92798   void * jresult ;
92799   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
92800
92801   {
92802     try {
92803       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
92804     } catch (std::out_of_range& e) {
92805       {
92806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92807       };
92808     } catch (std::exception& e) {
92809       {
92810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92811       };
92812     } catch (Dali::DaliException e) {
92813       {
92814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92815       };
92816     } catch (...) {
92817       {
92818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92819       };
92820     }
92821   }
92822
92823   jresult = (void *)result;
92824   return jresult;
92825 }
92826
92827
92828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
92829   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
92830
92831   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
92832   {
92833     try {
92834       delete arg1;
92835     } catch (std::out_of_range& e) {
92836       {
92837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92838       };
92839     } catch (std::exception& e) {
92840       {
92841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92842       };
92843     } catch (Dali::DaliException e) {
92844       {
92845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92846       };
92847     } catch (...) {
92848       {
92849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92850       };
92851     }
92852   }
92853
92854 }
92855
92856
92857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
92858   unsigned int jresult ;
92859   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
92860   bool result;
92861
92862   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
92863   {
92864     try {
92865       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
92866     } catch (std::out_of_range& e) {
92867       {
92868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92869       };
92870     } catch (std::exception& e) {
92871       {
92872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92873       };
92874     } catch (Dali::DaliException e) {
92875       {
92876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92877       };
92878     } catch (...) {
92879       {
92880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92881       };
92882     }
92883   }
92884
92885   jresult = result;
92886   return jresult;
92887 }
92888
92889
92890 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
92891   unsigned long jresult ;
92892   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
92893   std::size_t result;
92894
92895   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
92896   {
92897     try {
92898       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
92899     } catch (std::out_of_range& e) {
92900       {
92901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92902       };
92903     } catch (std::exception& e) {
92904       {
92905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92906       };
92907     } catch (Dali::DaliException e) {
92908       {
92909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92910       };
92911     } catch (...) {
92912       {
92913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92914       };
92915     }
92916   }
92917
92918   jresult = (unsigned long)result;
92919   return jresult;
92920 }
92921
92922
92923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
92924   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
92925   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
92926
92927   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
92928   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
92929   {
92930     try {
92931       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
92932     } catch (std::out_of_range& e) {
92933       {
92934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92935       };
92936     } catch (std::exception& e) {
92937       {
92938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92939       };
92940     } catch (Dali::DaliException e) {
92941       {
92942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92943       };
92944     } catch (...) {
92945       {
92946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92947       };
92948     }
92949   }
92950
92951 }
92952
92953
92954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
92955   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
92956   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
92957
92958   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
92959   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
92960   {
92961     try {
92962       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
92963     } catch (std::out_of_range& e) {
92964       {
92965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92966       };
92967     } catch (std::exception& e) {
92968       {
92969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92970       };
92971     } catch (Dali::DaliException e) {
92972       {
92973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92974       };
92975     } catch (...) {
92976       {
92977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92978       };
92979     }
92980   }
92981
92982 }
92983
92984
92985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
92986   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
92987   Dali::Toolkit::GaussianBlurView arg2 ;
92988   Dali::Toolkit::GaussianBlurView *argp2 ;
92989
92990   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
92991   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
92992   if (!argp2) {
92993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
92994     return ;
92995   }
92996   arg2 = *argp2;
92997   {
92998     try {
92999       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
93000     } catch (std::out_of_range& e) {
93001       {
93002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93003       };
93004     } catch (std::exception& e) {
93005       {
93006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93007       };
93008     } catch (Dali::DaliException e) {
93009       {
93010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93011       };
93012     } catch (...) {
93013       {
93014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93015       };
93016     }
93017   }
93018
93019 }
93020
93021
93022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
93023   void * jresult ;
93024   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
93025
93026   {
93027     try {
93028       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
93029     } catch (std::out_of_range& e) {
93030       {
93031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93032       };
93033     } catch (std::exception& e) {
93034       {
93035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93036       };
93037     } catch (Dali::DaliException e) {
93038       {
93039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93040       };
93041     } catch (...) {
93042       {
93043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93044       };
93045     }
93046   }
93047
93048   jresult = (void *)result;
93049   return jresult;
93050 }
93051
93052
93053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
93054   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
93055
93056   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
93057   {
93058     try {
93059       delete arg1;
93060     } catch (std::out_of_range& e) {
93061       {
93062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93063       };
93064     } catch (std::exception& e) {
93065       {
93066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93067       };
93068     } catch (Dali::DaliException e) {
93069       {
93070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93071       };
93072     } catch (...) {
93073       {
93074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93075       };
93076     }
93077   }
93078
93079 }
93080
93081
93082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
93083   unsigned int jresult ;
93084   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
93085   bool result;
93086
93087   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
93088   {
93089     try {
93090       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);
93091     } catch (std::out_of_range& e) {
93092       {
93093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93094       };
93095     } catch (std::exception& e) {
93096       {
93097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93098       };
93099     } catch (Dali::DaliException e) {
93100       {
93101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93102       };
93103     } catch (...) {
93104       {
93105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93106       };
93107     }
93108   }
93109
93110   jresult = result;
93111   return jresult;
93112 }
93113
93114
93115 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
93116   unsigned long jresult ;
93117   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
93118   std::size_t result;
93119
93120   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
93121   {
93122     try {
93123       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);
93124     } catch (std::out_of_range& e) {
93125       {
93126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93127       };
93128     } catch (std::exception& e) {
93129       {
93130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93131       };
93132     } catch (Dali::DaliException e) {
93133       {
93134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93135       };
93136     } catch (...) {
93137       {
93138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93139       };
93140     }
93141   }
93142
93143   jresult = (unsigned long)result;
93144   return jresult;
93145 }
93146
93147
93148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
93149   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
93150   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
93151
93152   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
93153   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
93154   {
93155     try {
93156       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
93157     } catch (std::out_of_range& e) {
93158       {
93159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93160       };
93161     } catch (std::exception& e) {
93162       {
93163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93164       };
93165     } catch (Dali::DaliException e) {
93166       {
93167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93168       };
93169     } catch (...) {
93170       {
93171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93172       };
93173     }
93174   }
93175
93176 }
93177
93178
93179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
93180   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
93181   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
93182
93183   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
93184   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
93185   {
93186     try {
93187       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
93188     } catch (std::out_of_range& e) {
93189       {
93190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93191       };
93192     } catch (std::exception& e) {
93193       {
93194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93195       };
93196     } catch (Dali::DaliException e) {
93197       {
93198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93199       };
93200     } catch (...) {
93201       {
93202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93203       };
93204     }
93205   }
93206
93207 }
93208
93209
93210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
93211   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
93212   Dali::Toolkit::PageTurnView arg2 ;
93213   unsigned int arg3 ;
93214   bool arg4 ;
93215   Dali::Toolkit::PageTurnView *argp2 ;
93216
93217   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
93218   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
93219   if (!argp2) {
93220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
93221     return ;
93222   }
93223   arg2 = *argp2;
93224   arg3 = (unsigned int)jarg3;
93225   arg4 = jarg4 ? true : false;
93226   {
93227     try {
93228       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
93229     } catch (std::out_of_range& e) {
93230       {
93231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93232       };
93233     } catch (std::exception& e) {
93234       {
93235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93236       };
93237     } catch (Dali::DaliException e) {
93238       {
93239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93240       };
93241     } catch (...) {
93242       {
93243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93244       };
93245     }
93246   }
93247
93248 }
93249
93250
93251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
93252   void * jresult ;
93253   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
93254
93255   {
93256     try {
93257       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
93258     } catch (std::out_of_range& e) {
93259       {
93260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93261       };
93262     } catch (std::exception& e) {
93263       {
93264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93265       };
93266     } catch (Dali::DaliException e) {
93267       {
93268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93269       };
93270     } catch (...) {
93271       {
93272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93273       };
93274     }
93275   }
93276
93277   jresult = (void *)result;
93278   return jresult;
93279 }
93280
93281
93282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
93283   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
93284
93285   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
93286   {
93287     try {
93288       delete arg1;
93289     } catch (std::out_of_range& e) {
93290       {
93291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93292       };
93293     } catch (std::exception& e) {
93294       {
93295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93296       };
93297     } catch (Dali::DaliException e) {
93298       {
93299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93300       };
93301     } catch (...) {
93302       {
93303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93304       };
93305     }
93306   }
93307
93308 }
93309
93310
93311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
93312   unsigned int jresult ;
93313   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
93314   bool result;
93315
93316   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
93317   {
93318     try {
93319       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
93320     } catch (std::out_of_range& e) {
93321       {
93322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93323       };
93324     } catch (std::exception& e) {
93325       {
93326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93327       };
93328     } catch (Dali::DaliException e) {
93329       {
93330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93331       };
93332     } catch (...) {
93333       {
93334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93335       };
93336     }
93337   }
93338
93339   jresult = result;
93340   return jresult;
93341 }
93342
93343
93344 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
93345   unsigned long jresult ;
93346   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
93347   std::size_t result;
93348
93349   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
93350   {
93351     try {
93352       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
93353     } catch (std::out_of_range& e) {
93354       {
93355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93356       };
93357     } catch (std::exception& e) {
93358       {
93359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93360       };
93361     } catch (Dali::DaliException e) {
93362       {
93363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93364       };
93365     } catch (...) {
93366       {
93367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93368       };
93369     }
93370   }
93371
93372   jresult = (unsigned long)result;
93373   return jresult;
93374 }
93375
93376
93377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
93378   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
93379   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
93380
93381   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
93382   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
93383   {
93384     try {
93385       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
93386     } catch (std::out_of_range& e) {
93387       {
93388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93389       };
93390     } catch (std::exception& e) {
93391       {
93392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93393       };
93394     } catch (Dali::DaliException e) {
93395       {
93396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93397       };
93398     } catch (...) {
93399       {
93400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93401       };
93402     }
93403   }
93404
93405 }
93406
93407
93408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
93409   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
93410   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
93411
93412   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
93413   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
93414   {
93415     try {
93416       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
93417     } catch (std::out_of_range& e) {
93418       {
93419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93420       };
93421     } catch (std::exception& e) {
93422       {
93423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93424       };
93425     } catch (Dali::DaliException e) {
93426       {
93427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93428       };
93429     } catch (...) {
93430       {
93431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93432       };
93433     }
93434   }
93435
93436 }
93437
93438
93439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
93440   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
93441   Dali::Toolkit::PageTurnView arg2 ;
93442   Dali::Toolkit::PageTurnView *argp2 ;
93443
93444   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
93445   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
93446   if (!argp2) {
93447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
93448     return ;
93449   }
93450   arg2 = *argp2;
93451   {
93452     try {
93453       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
93454     } catch (std::out_of_range& e) {
93455       {
93456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93457       };
93458     } catch (std::exception& e) {
93459       {
93460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93461       };
93462     } catch (Dali::DaliException e) {
93463       {
93464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93465       };
93466     } catch (...) {
93467       {
93468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93469       };
93470     }
93471   }
93472
93473 }
93474
93475
93476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
93477   void * jresult ;
93478   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
93479
93480   {
93481     try {
93482       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
93483     } catch (std::out_of_range& e) {
93484       {
93485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93486       };
93487     } catch (std::exception& e) {
93488       {
93489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93490       };
93491     } catch (Dali::DaliException e) {
93492       {
93493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93494       };
93495     } catch (...) {
93496       {
93497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93498       };
93499     }
93500   }
93501
93502   jresult = (void *)result;
93503   return jresult;
93504 }
93505
93506
93507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
93508   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
93509
93510   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
93511   {
93512     try {
93513       delete arg1;
93514     } catch (std::out_of_range& e) {
93515       {
93516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93517       };
93518     } catch (std::exception& e) {
93519       {
93520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93521       };
93522     } catch (Dali::DaliException e) {
93523       {
93524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93525       };
93526     } catch (...) {
93527       {
93528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93529       };
93530     }
93531   }
93532
93533 }
93534
93535
93536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
93537   unsigned int jresult ;
93538   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
93539   bool result;
93540
93541   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
93542   {
93543     try {
93544       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);
93545     } catch (std::out_of_range& e) {
93546       {
93547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93548       };
93549     } catch (std::exception& e) {
93550       {
93551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93552       };
93553     } catch (Dali::DaliException e) {
93554       {
93555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93556       };
93557     } catch (...) {
93558       {
93559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93560       };
93561     }
93562   }
93563
93564   jresult = result;
93565   return jresult;
93566 }
93567
93568
93569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
93570   unsigned long jresult ;
93571   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
93572   std::size_t result;
93573
93574   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
93575   {
93576     try {
93577       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);
93578     } catch (std::out_of_range& e) {
93579       {
93580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93581       };
93582     } catch (std::exception& e) {
93583       {
93584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93585       };
93586     } catch (Dali::DaliException e) {
93587       {
93588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93589       };
93590     } catch (...) {
93591       {
93592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93593       };
93594     }
93595   }
93596
93597   jresult = (unsigned long)result;
93598   return jresult;
93599 }
93600
93601
93602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
93603   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
93604   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
93605
93606   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
93607   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
93608   {
93609     try {
93610       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
93611     } catch (std::out_of_range& e) {
93612       {
93613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93614       };
93615     } catch (std::exception& e) {
93616       {
93617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93618       };
93619     } catch (Dali::DaliException e) {
93620       {
93621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93622       };
93623     } catch (...) {
93624       {
93625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93626       };
93627     }
93628   }
93629
93630 }
93631
93632
93633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93634   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
93635   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
93636
93637   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
93638   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
93639   {
93640     try {
93641       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
93642     } catch (std::out_of_range& e) {
93643       {
93644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93645       };
93646     } catch (std::exception& e) {
93647       {
93648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93649       };
93650     } catch (Dali::DaliException e) {
93651       {
93652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93653       };
93654     } catch (...) {
93655       {
93656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93657       };
93658     }
93659   }
93660
93661 }
93662
93663
93664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
93665   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
93666   Dali::Toolkit::ProgressBar arg2 ;
93667   float arg3 ;
93668   float arg4 ;
93669   Dali::Toolkit::ProgressBar *argp2 ;
93670
93671   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
93672   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
93673   if (!argp2) {
93674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
93675     return ;
93676   }
93677   arg2 = *argp2;
93678   arg3 = (float)jarg3;
93679   arg4 = (float)jarg4;
93680   {
93681     try {
93682       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
93683     } catch (std::out_of_range& e) {
93684       {
93685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93686       };
93687     } catch (std::exception& e) {
93688       {
93689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93690       };
93691     } catch (Dali::DaliException e) {
93692       {
93693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93694       };
93695     } catch (...) {
93696       {
93697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93698       };
93699     }
93700   }
93701
93702 }
93703
93704
93705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
93706   void * jresult ;
93707   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
93708
93709   {
93710     try {
93711       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
93712     } catch (std::out_of_range& e) {
93713       {
93714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93715       };
93716     } catch (std::exception& e) {
93717       {
93718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93719       };
93720     } catch (Dali::DaliException e) {
93721       {
93722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93723       };
93724     } catch (...) {
93725       {
93726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93727       };
93728     }
93729   }
93730
93731   jresult = (void *)result;
93732   return jresult;
93733 }
93734
93735
93736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
93737   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
93738
93739   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
93740   {
93741     try {
93742       delete arg1;
93743     } catch (std::out_of_range& e) {
93744       {
93745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93746       };
93747     } catch (std::exception& e) {
93748       {
93749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93750       };
93751     } catch (Dali::DaliException e) {
93752       {
93753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93754       };
93755     } catch (...) {
93756       {
93757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93758       };
93759     }
93760   }
93761
93762 }
93763
93764
93765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
93766   unsigned int jresult ;
93767   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
93768   bool result;
93769
93770   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
93771   {
93772     try {
93773       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);
93774     } catch (std::out_of_range& e) {
93775       {
93776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93777       };
93778     } catch (std::exception& e) {
93779       {
93780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93781       };
93782     } catch (Dali::DaliException e) {
93783       {
93784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93785       };
93786     } catch (...) {
93787       {
93788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93789       };
93790     }
93791   }
93792
93793   jresult = result;
93794   return jresult;
93795 }
93796
93797
93798 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
93799   unsigned long jresult ;
93800   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
93801   std::size_t result;
93802
93803   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
93804   {
93805     try {
93806       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);
93807     } catch (std::out_of_range& e) {
93808       {
93809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93810       };
93811     } catch (std::exception& e) {
93812       {
93813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93814       };
93815     } catch (Dali::DaliException e) {
93816       {
93817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93818       };
93819     } catch (...) {
93820       {
93821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93822       };
93823     }
93824   }
93825
93826   jresult = (unsigned long)result;
93827   return jresult;
93828 }
93829
93830
93831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
93832   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
93833   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
93834
93835   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
93836   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
93837   {
93838     try {
93839       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
93840     } catch (std::out_of_range& e) {
93841       {
93842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93843       };
93844     } catch (std::exception& e) {
93845       {
93846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93847       };
93848     } catch (Dali::DaliException e) {
93849       {
93850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93851       };
93852     } catch (...) {
93853       {
93854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93855       };
93856     }
93857   }
93858
93859 }
93860
93861
93862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
93863   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
93864   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
93865
93866   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
93867   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
93868   {
93869     try {
93870       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
93871     } catch (std::out_of_range& e) {
93872       {
93873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93874       };
93875     } catch (std::exception& e) {
93876       {
93877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93878       };
93879     } catch (Dali::DaliException e) {
93880       {
93881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93882       };
93883     } catch (...) {
93884       {
93885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93886       };
93887     }
93888   }
93889
93890 }
93891
93892
93893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
93894   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
93895   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
93896
93897   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
93898   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
93899   if (!arg2) {
93900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
93901     return ;
93902   }
93903   {
93904     try {
93905       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
93906     } catch (std::out_of_range& e) {
93907       {
93908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93909       };
93910     } catch (std::exception& e) {
93911       {
93912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93913       };
93914     } catch (Dali::DaliException e) {
93915       {
93916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93917       };
93918     } catch (...) {
93919       {
93920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93921       };
93922     }
93923   }
93924
93925 }
93926
93927
93928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
93929   void * jresult ;
93930   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
93931
93932   {
93933     try {
93934       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
93935     } catch (std::out_of_range& e) {
93936       {
93937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93938       };
93939     } catch (std::exception& e) {
93940       {
93941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93942       };
93943     } catch (Dali::DaliException e) {
93944       {
93945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93946       };
93947     } catch (...) {
93948       {
93949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93950       };
93951     }
93952   }
93953
93954   jresult = (void *)result;
93955   return jresult;
93956 }
93957
93958
93959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
93960   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
93961
93962   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
93963   {
93964     try {
93965       delete arg1;
93966     } catch (std::out_of_range& e) {
93967       {
93968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93969       };
93970     } catch (std::exception& e) {
93971       {
93972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93973       };
93974     } catch (Dali::DaliException e) {
93975       {
93976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93977       };
93978     } catch (...) {
93979       {
93980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93981       };
93982     }
93983   }
93984
93985 }
93986
93987
93988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
93989   unsigned int jresult ;
93990   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
93991   bool result;
93992
93993   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
93994   {
93995     try {
93996       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
93997     } catch (std::out_of_range& e) {
93998       {
93999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94000       };
94001     } catch (std::exception& e) {
94002       {
94003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94004       };
94005     } catch (Dali::DaliException e) {
94006       {
94007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94008       };
94009     } catch (...) {
94010       {
94011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94012       };
94013     }
94014   }
94015
94016   jresult = result;
94017   return jresult;
94018 }
94019
94020
94021 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
94022   unsigned long jresult ;
94023   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
94024   std::size_t result;
94025
94026   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
94027   {
94028     try {
94029       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
94030     } catch (std::out_of_range& e) {
94031       {
94032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94033       };
94034     } catch (std::exception& e) {
94035       {
94036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94037       };
94038     } catch (Dali::DaliException e) {
94039       {
94040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94041       };
94042     } catch (...) {
94043       {
94044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94045       };
94046     }
94047   }
94048
94049   jresult = (unsigned long)result;
94050   return jresult;
94051 }
94052
94053
94054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
94055   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
94056   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
94057
94058   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
94059   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
94060   {
94061     try {
94062       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
94063     } catch (std::out_of_range& e) {
94064       {
94065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94066       };
94067     } catch (std::exception& e) {
94068       {
94069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94070       };
94071     } catch (Dali::DaliException e) {
94072       {
94073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94074       };
94075     } catch (...) {
94076       {
94077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94078       };
94079     }
94080   }
94081
94082 }
94083
94084
94085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
94086   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
94087   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
94088
94089   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
94090   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
94091   {
94092     try {
94093       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
94094     } catch (std::out_of_range& e) {
94095       {
94096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94097       };
94098     } catch (std::exception& e) {
94099       {
94100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94101       };
94102     } catch (Dali::DaliException e) {
94103       {
94104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94105       };
94106     } catch (...) {
94107       {
94108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94109       };
94110     }
94111   }
94112
94113 }
94114
94115
94116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
94117   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
94118   Dali::Vector2 *arg2 = 0 ;
94119
94120   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
94121   arg2 = (Dali::Vector2 *)jarg2;
94122   if (!arg2) {
94123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
94124     return ;
94125   }
94126   {
94127     try {
94128       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
94129     } catch (std::out_of_range& e) {
94130       {
94131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94132       };
94133     } catch (std::exception& e) {
94134       {
94135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94136       };
94137     } catch (Dali::DaliException e) {
94138       {
94139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94140       };
94141     } catch (...) {
94142       {
94143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94144       };
94145     }
94146   }
94147
94148 }
94149
94150
94151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
94152   void * jresult ;
94153   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
94154
94155   {
94156     try {
94157       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
94158     } catch (std::out_of_range& e) {
94159       {
94160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94161       };
94162     } catch (std::exception& e) {
94163       {
94164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94165       };
94166     } catch (Dali::DaliException e) {
94167       {
94168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94169       };
94170     } catch (...) {
94171       {
94172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94173       };
94174     }
94175   }
94176
94177   jresult = (void *)result;
94178   return jresult;
94179 }
94180
94181
94182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
94183   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
94184
94185   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
94186   {
94187     try {
94188       delete arg1;
94189     } catch (std::out_of_range& e) {
94190       {
94191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94192       };
94193     } catch (std::exception& e) {
94194       {
94195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94196       };
94197     } catch (Dali::DaliException e) {
94198       {
94199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94200       };
94201     } catch (...) {
94202       {
94203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94204       };
94205     }
94206   }
94207
94208 }
94209
94210
94211
94212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
94213   unsigned int jresult ;
94214   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
94215   bool result;
94216
94217   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
94218   {
94219     try {
94220       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);
94221     } catch (std::out_of_range& e) {
94222       {
94223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94224       };
94225     } catch (std::exception& e) {
94226       {
94227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94228       };
94229     } catch (Dali::DaliException e) {
94230       {
94231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94232       };
94233     } catch (...) {
94234       {
94235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94236       };
94237     }
94238   }
94239
94240   jresult = result;
94241   return jresult;
94242 }
94243
94244
94245 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
94246   unsigned long jresult ;
94247   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
94248   std::size_t result;
94249
94250   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
94251   {
94252     try {
94253       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);
94254     } catch (std::out_of_range& e) {
94255       {
94256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94257       };
94258     } catch (std::exception& e) {
94259       {
94260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94261       };
94262     } catch (Dali::DaliException e) {
94263       {
94264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94265       };
94266     } catch (...) {
94267       {
94268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94269       };
94270     }
94271   }
94272
94273   jresult = (unsigned long)result;
94274   return jresult;
94275 }
94276
94277
94278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
94279   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
94280   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
94281
94282   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
94283   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
94284   {
94285     try {
94286       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
94287     } catch (std::out_of_range& e) {
94288       {
94289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94290       };
94291     } catch (std::exception& e) {
94292       {
94293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94294       };
94295     } catch (Dali::DaliException e) {
94296       {
94297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94298       };
94299     } catch (...) {
94300       {
94301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94302       };
94303     }
94304   }
94305
94306 }
94307
94308
94309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
94310   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
94311   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
94312
94313   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
94314   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
94315   {
94316     try {
94317       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
94318     } catch (std::out_of_range& e) {
94319       {
94320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94321       };
94322     } catch (std::exception& e) {
94323       {
94324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94325       };
94326     } catch (Dali::DaliException e) {
94327       {
94328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94329       };
94330     } catch (...) {
94331       {
94332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94333       };
94334     }
94335   }
94336
94337 }
94338
94339
94340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
94341   unsigned int jresult ;
94342   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
94343   Dali::Toolkit::Control arg2 ;
94344   Dali::KeyEvent *arg3 = 0 ;
94345   Dali::Toolkit::Control *argp2 ;
94346   bool result;
94347
94348   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
94349   argp2 = (Dali::Toolkit::Control *)jarg2;
94350   if (!argp2) {
94351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
94352     return 0;
94353   }
94354   arg2 = *argp2;
94355   arg3 = (Dali::KeyEvent *)jarg3;
94356   if (!arg3) {
94357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
94358     return 0;
94359   }
94360   {
94361     try {
94362       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);
94363     } catch (std::out_of_range& e) {
94364       {
94365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94366       };
94367     } catch (std::exception& e) {
94368       {
94369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94370       };
94371     } catch (Dali::DaliException e) {
94372       {
94373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94374       };
94375     } catch (...) {
94376       {
94377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94378       };
94379     }
94380   }
94381
94382   jresult = result;
94383   return jresult;
94384 }
94385
94386
94387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
94388   void * jresult ;
94389   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
94390
94391   {
94392     try {
94393       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
94394     } catch (std::out_of_range& e) {
94395       {
94396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94397       };
94398     } catch (std::exception& e) {
94399       {
94400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94401       };
94402     } catch (Dali::DaliException e) {
94403       {
94404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94405       };
94406     } catch (...) {
94407       {
94408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94409       };
94410     }
94411   }
94412
94413   jresult = (void *)result;
94414   return jresult;
94415 }
94416
94417
94418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
94419   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
94420
94421   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
94422   {
94423     try {
94424       delete arg1;
94425     } catch (std::out_of_range& e) {
94426       {
94427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94428       };
94429     } catch (std::exception& e) {
94430       {
94431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94432       };
94433     } catch (Dali::DaliException e) {
94434       {
94435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94436       };
94437     } catch (...) {
94438       {
94439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94440       };
94441     }
94442   }
94443
94444 }
94445
94446
94447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
94448   unsigned int jresult ;
94449   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94450   bool result;
94451
94452   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94453   {
94454     try {
94455       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
94456     } catch (std::out_of_range& e) {
94457       {
94458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94459       };
94460     } catch (std::exception& e) {
94461       {
94462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94463       };
94464     } catch (Dali::DaliException e) {
94465       {
94466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94467       };
94468     } catch (...) {
94469       {
94470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94471       };
94472     }
94473   }
94474
94475   jresult = result;
94476   return jresult;
94477 }
94478
94479
94480 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
94481   unsigned long jresult ;
94482   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94483   std::size_t result;
94484
94485   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94486   {
94487     try {
94488       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
94489     } catch (std::out_of_range& e) {
94490       {
94491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94492       };
94493     } catch (std::exception& e) {
94494       {
94495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94496       };
94497     } catch (Dali::DaliException e) {
94498       {
94499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94500       };
94501     } catch (...) {
94502       {
94503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94504       };
94505     }
94506   }
94507
94508   jresult = (unsigned long)result;
94509   return jresult;
94510 }
94511
94512
94513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
94514   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94515   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
94516
94517   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94518   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
94519   {
94520     try {
94521       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
94522     } catch (std::out_of_range& e) {
94523       {
94524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94525       };
94526     } catch (std::exception& e) {
94527       {
94528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94529       };
94530     } catch (Dali::DaliException e) {
94531       {
94532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94533       };
94534     } catch (...) {
94535       {
94536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94537       };
94538     }
94539   }
94540
94541 }
94542
94543
94544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
94545   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94546   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
94547
94548   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94549   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
94550   {
94551     try {
94552       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
94553     } catch (std::out_of_range& e) {
94554       {
94555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94556       };
94557     } catch (std::exception& e) {
94558       {
94559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94560       };
94561     } catch (Dali::DaliException e) {
94562       {
94563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94564       };
94565     } catch (...) {
94566       {
94567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94568       };
94569     }
94570   }
94571
94572 }
94573
94574
94575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
94576   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94577   Dali::Toolkit::Control arg2 ;
94578   Dali::Toolkit::Control *argp2 ;
94579
94580   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94581   argp2 = (Dali::Toolkit::Control *)jarg2;
94582   if (!argp2) {
94583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
94584     return ;
94585   }
94586   arg2 = *argp2;
94587   {
94588     try {
94589       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
94590     } catch (std::out_of_range& e) {
94591       {
94592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94593       };
94594     } catch (std::exception& e) {
94595       {
94596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94597       };
94598     } catch (Dali::DaliException e) {
94599       {
94600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94601       };
94602     } catch (...) {
94603       {
94604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94605       };
94606     }
94607   }
94608
94609 }
94610
94611
94612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
94613   void * jresult ;
94614   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
94615
94616   {
94617     try {
94618       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
94619     } catch (std::out_of_range& e) {
94620       {
94621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94622       };
94623     } catch (std::exception& e) {
94624       {
94625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94626       };
94627     } catch (Dali::DaliException e) {
94628       {
94629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94630       };
94631     } catch (...) {
94632       {
94633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94634       };
94635     }
94636   }
94637
94638   jresult = (void *)result;
94639   return jresult;
94640 }
94641
94642
94643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
94644   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94645
94646   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94647   {
94648     try {
94649       delete arg1;
94650     } catch (std::out_of_range& e) {
94651       {
94652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94653       };
94654     } catch (std::exception& e) {
94655       {
94656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94657       };
94658     } catch (Dali::DaliException e) {
94659       {
94660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94661       };
94662     } catch (...) {
94663       {
94664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94665       };
94666     }
94667   }
94668
94669 }
94670
94671
94672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
94673   unsigned int jresult ;
94674   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
94675   bool result;
94676
94677   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
94678   {
94679     try {
94680       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
94681     } catch (std::out_of_range& e) {
94682       {
94683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94684       };
94685     } catch (std::exception& e) {
94686       {
94687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94688       };
94689     } catch (Dali::DaliException e) {
94690       {
94691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94692       };
94693     } catch (...) {
94694       {
94695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94696       };
94697     }
94698   }
94699
94700   jresult = result;
94701   return jresult;
94702 }
94703
94704
94705 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
94706   unsigned long jresult ;
94707   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
94708   std::size_t result;
94709
94710   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
94711   {
94712     try {
94713       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
94714     } catch (std::out_of_range& e) {
94715       {
94716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94717       };
94718     } catch (std::exception& e) {
94719       {
94720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94721       };
94722     } catch (Dali::DaliException e) {
94723       {
94724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94725       };
94726     } catch (...) {
94727       {
94728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94729       };
94730     }
94731   }
94732
94733   jresult = (unsigned long)result;
94734   return jresult;
94735 }
94736
94737
94738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
94739   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
94740   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
94741
94742   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
94743   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
94744   {
94745     try {
94746       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
94747     } catch (std::out_of_range& e) {
94748       {
94749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94750       };
94751     } catch (std::exception& e) {
94752       {
94753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94754       };
94755     } catch (Dali::DaliException e) {
94756       {
94757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94758       };
94759     } catch (...) {
94760       {
94761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94762       };
94763     }
94764   }
94765
94766 }
94767
94768
94769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
94770   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
94771   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
94772
94773   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
94774   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
94775   {
94776     try {
94777       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
94778     } catch (std::out_of_range& e) {
94779       {
94780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94781       };
94782     } catch (std::exception& e) {
94783       {
94784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94785       };
94786     } catch (Dali::DaliException e) {
94787       {
94788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94789       };
94790     } catch (...) {
94791       {
94792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94793       };
94794     }
94795   }
94796
94797 }
94798
94799
94800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
94801   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
94802   Dali::Toolkit::VideoView *arg2 = 0 ;
94803
94804   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
94805   arg2 = (Dali::Toolkit::VideoView *)jarg2;
94806   if (!arg2) {
94807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
94808     return ;
94809   }
94810   {
94811     try {
94812       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
94813     } catch (std::out_of_range& e) {
94814       {
94815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94816       };
94817     } catch (std::exception& e) {
94818       {
94819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94820       };
94821     } catch (Dali::DaliException e) {
94822       {
94823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94824       };
94825     } catch (...) {
94826       {
94827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94828       };
94829     }
94830   }
94831
94832 }
94833
94834
94835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
94836   void * jresult ;
94837   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
94838
94839   {
94840     try {
94841       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
94842     } catch (std::out_of_range& e) {
94843       {
94844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94845       };
94846     } catch (std::exception& e) {
94847       {
94848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94849       };
94850     } catch (Dali::DaliException e) {
94851       {
94852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94853       };
94854     } catch (...) {
94855       {
94856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94857       };
94858     }
94859   }
94860
94861   jresult = (void *)result;
94862   return jresult;
94863 }
94864
94865
94866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
94867   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
94868
94869   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
94870   {
94871     try {
94872       delete arg1;
94873     } catch (std::out_of_range& e) {
94874       {
94875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94876       };
94877     } catch (std::exception& e) {
94878       {
94879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94880       };
94881     } catch (Dali::DaliException e) {
94882       {
94883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94884       };
94885     } catch (...) {
94886       {
94887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94888       };
94889     }
94890   }
94891
94892 }
94893
94894
94895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
94896   unsigned int jresult ;
94897   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
94898   bool result;
94899
94900   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
94901   {
94902     try {
94903       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
94904     } catch (std::out_of_range& e) {
94905       {
94906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94907       };
94908     } catch (std::exception& e) {
94909       {
94910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94911       };
94912     } catch (Dali::DaliException e) {
94913       {
94914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94915       };
94916     } catch (...) {
94917       {
94918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94919       };
94920     }
94921   }
94922
94923   jresult = result;
94924   return jresult;
94925 }
94926
94927
94928 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
94929   unsigned long jresult ;
94930   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
94931   std::size_t result;
94932
94933   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
94934   {
94935     try {
94936       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
94937     } catch (std::out_of_range& e) {
94938       {
94939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94940       };
94941     } catch (std::exception& e) {
94942       {
94943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94944       };
94945     } catch (Dali::DaliException e) {
94946       {
94947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94948       };
94949     } catch (...) {
94950       {
94951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94952       };
94953     }
94954   }
94955
94956   jresult = (unsigned long)result;
94957   return jresult;
94958 }
94959
94960
94961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
94962   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
94963   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
94964
94965   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
94966   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
94967   {
94968     try {
94969       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
94970     } catch (std::out_of_range& e) {
94971       {
94972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94973       };
94974     } catch (std::exception& e) {
94975       {
94976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94977       };
94978     } catch (Dali::DaliException e) {
94979       {
94980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94981       };
94982     } catch (...) {
94983       {
94984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94985       };
94986     }
94987   }
94988
94989 }
94990
94991
94992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94993   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
94994   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
94995
94996   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
94997   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
94998   {
94999     try {
95000       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
95001     } catch (std::out_of_range& e) {
95002       {
95003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95004       };
95005     } catch (std::exception& e) {
95006       {
95007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95008       };
95009     } catch (Dali::DaliException e) {
95010       {
95011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95012       };
95013     } catch (...) {
95014       {
95015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95016       };
95017     }
95018   }
95019
95020 }
95021
95022
95023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
95024   unsigned int jresult ;
95025   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
95026   Dali::Toolkit::Slider arg2 ;
95027   float arg3 ;
95028   Dali::Toolkit::Slider *argp2 ;
95029   bool result;
95030
95031   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
95032   argp2 = (Dali::Toolkit::Slider *)jarg2;
95033   if (!argp2) {
95034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
95035     return 0;
95036   }
95037   arg2 = *argp2;
95038   arg3 = (float)jarg3;
95039   {
95040     try {
95041       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
95042     } catch (std::out_of_range& e) {
95043       {
95044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95045       };
95046     } catch (std::exception& e) {
95047       {
95048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95049       };
95050     } catch (Dali::DaliException e) {
95051       {
95052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95053       };
95054     } catch (...) {
95055       {
95056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95057       };
95058     }
95059   }
95060
95061   jresult = result;
95062   return jresult;
95063 }
95064
95065
95066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
95067   void * jresult ;
95068   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
95069
95070   {
95071     try {
95072       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
95073     } catch (std::out_of_range& e) {
95074       {
95075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95076       };
95077     } catch (std::exception& e) {
95078       {
95079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95080       };
95081     } catch (Dali::DaliException e) {
95082       {
95083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95084       };
95085     } catch (...) {
95086       {
95087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95088       };
95089     }
95090   }
95091
95092   jresult = (void *)result;
95093   return jresult;
95094 }
95095
95096
95097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
95098   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
95099
95100   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
95101   {
95102     try {
95103       delete arg1;
95104     } catch (std::out_of_range& e) {
95105       {
95106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95107       };
95108     } catch (std::exception& e) {
95109       {
95110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95111       };
95112     } catch (Dali::DaliException e) {
95113       {
95114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95115       };
95116     } catch (...) {
95117       {
95118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95119       };
95120     }
95121   }
95122
95123 }
95124
95125
95126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
95127   unsigned int jresult ;
95128   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
95129   bool result;
95130
95131   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
95132   {
95133     try {
95134       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
95135     } catch (std::out_of_range& e) {
95136       {
95137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95138       };
95139     } catch (std::exception& e) {
95140       {
95141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95142       };
95143     } catch (Dali::DaliException e) {
95144       {
95145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95146       };
95147     } catch (...) {
95148       {
95149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95150       };
95151     }
95152   }
95153
95154   jresult = result;
95155   return jresult;
95156 }
95157
95158
95159 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
95160   unsigned long jresult ;
95161   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
95162   std::size_t result;
95163
95164   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
95165   {
95166     try {
95167       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
95168     } catch (std::out_of_range& e) {
95169       {
95170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95171       };
95172     } catch (std::exception& e) {
95173       {
95174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95175       };
95176     } catch (Dali::DaliException e) {
95177       {
95178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95179       };
95180     } catch (...) {
95181       {
95182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95183       };
95184     }
95185   }
95186
95187   jresult = (unsigned long)result;
95188   return jresult;
95189 }
95190
95191
95192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
95193   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
95194   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
95195
95196   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
95197   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
95198   {
95199     try {
95200       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
95201     } catch (std::out_of_range& e) {
95202       {
95203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95204       };
95205     } catch (std::exception& e) {
95206       {
95207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95208       };
95209     } catch (Dali::DaliException e) {
95210       {
95211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95212       };
95213     } catch (...) {
95214       {
95215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95216       };
95217     }
95218   }
95219
95220 }
95221
95222
95223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
95224   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
95225   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
95226
95227   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
95228   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
95229   {
95230     try {
95231       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
95232     } catch (std::out_of_range& e) {
95233       {
95234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95235       };
95236     } catch (std::exception& e) {
95237       {
95238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95239       };
95240     } catch (Dali::DaliException e) {
95241       {
95242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95243       };
95244     } catch (...) {
95245       {
95246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95247       };
95248     }
95249   }
95250
95251 }
95252
95253
95254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95255   unsigned int jresult ;
95256   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
95257   Dali::Toolkit::Slider arg2 ;
95258   int arg3 ;
95259   Dali::Toolkit::Slider *argp2 ;
95260   bool result;
95261
95262   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
95263   argp2 = (Dali::Toolkit::Slider *)jarg2;
95264   if (!argp2) {
95265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
95266     return 0;
95267   }
95268   arg2 = *argp2;
95269   arg3 = (int)jarg3;
95270   {
95271     try {
95272       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
95273     } catch (std::out_of_range& e) {
95274       {
95275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95276       };
95277     } catch (std::exception& e) {
95278       {
95279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95280       };
95281     } catch (Dali::DaliException e) {
95282       {
95283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95284       };
95285     } catch (...) {
95286       {
95287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95288       };
95289     }
95290   }
95291
95292   jresult = result;
95293   return jresult;
95294 }
95295
95296
95297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
95298   void * jresult ;
95299   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
95300
95301   {
95302     try {
95303       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
95304     } catch (std::out_of_range& e) {
95305       {
95306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95307       };
95308     } catch (std::exception& e) {
95309       {
95310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95311       };
95312     } catch (Dali::DaliException e) {
95313       {
95314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95315       };
95316     } catch (...) {
95317       {
95318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95319       };
95320     }
95321   }
95322
95323   jresult = (void *)result;
95324   return jresult;
95325 }
95326
95327
95328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
95329   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
95330
95331   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
95332   {
95333     try {
95334       delete arg1;
95335     } catch (std::out_of_range& e) {
95336       {
95337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95338       };
95339     } catch (std::exception& e) {
95340       {
95341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95342       };
95343     } catch (Dali::DaliException e) {
95344       {
95345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95346       };
95347     } catch (...) {
95348       {
95349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95350       };
95351     }
95352   }
95353
95354 }
95355
95356
95357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
95358   void * jresult ;
95359   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
95360
95361   {
95362     try {
95363       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
95364     } catch (std::out_of_range& e) {
95365       {
95366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95367       };
95368     } catch (std::exception& e) {
95369       {
95370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95371       };
95372     } catch (Dali::DaliException e) {
95373       {
95374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95375       };
95376     } catch (...) {
95377       {
95378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95379       };
95380     }
95381   }
95382
95383   jresult = (void *)result;
95384   return jresult;
95385 }
95386
95387
95388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
95389   void * jresult ;
95390   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
95391   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
95392
95393   arg1 = (Dali::Toolkit::Ruler *)jarg1;
95394   {
95395     try {
95396       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
95397     } catch (std::out_of_range& e) {
95398       {
95399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95400       };
95401     } catch (std::exception& e) {
95402       {
95403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95404       };
95405     } catch (Dali::DaliException e) {
95406       {
95407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95408       };
95409     } catch (...) {
95410       {
95411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95412       };
95413     }
95414   }
95415
95416   jresult = (void *)result;
95417   return jresult;
95418 }
95419
95420
95421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
95422   void * jresult ;
95423   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
95424   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
95425
95426   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95427   if (!arg1) {
95428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
95429     return 0;
95430   }
95431   {
95432     try {
95433       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
95434     } catch (std::out_of_range& e) {
95435       {
95436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95437       };
95438     } catch (std::exception& e) {
95439       {
95440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95441       };
95442     } catch (Dali::DaliException e) {
95443       {
95444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95445       };
95446     } catch (...) {
95447       {
95448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95449       };
95450     }
95451   }
95452
95453   jresult = (void *)result;
95454   return jresult;
95455 }
95456
95457
95458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
95459   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95460
95461   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95462   {
95463     try {
95464       delete arg1;
95465     } catch (std::out_of_range& e) {
95466       {
95467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95468       };
95469     } catch (std::exception& e) {
95470       {
95471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95472       };
95473     } catch (Dali::DaliException e) {
95474       {
95475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95476       };
95477     } catch (...) {
95478       {
95479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95480       };
95481     }
95482   }
95483
95484 }
95485
95486
95487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
95488   void * jresult ;
95489   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95490   Dali::Toolkit::Ruler *result = 0 ;
95491
95492   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95493   {
95494     try {
95495       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
95496     } catch (std::out_of_range& e) {
95497       {
95498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95499       };
95500     } catch (std::exception& e) {
95501       {
95502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95503       };
95504     } catch (Dali::DaliException e) {
95505       {
95506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95507       };
95508     } catch (...) {
95509       {
95510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95511       };
95512     }
95513   }
95514
95515   jresult = (void *)result;
95516   return jresult;
95517 }
95518
95519
95520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
95521   void * jresult ;
95522   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95523   Dali::Toolkit::Ruler *result = 0 ;
95524
95525   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95526   {
95527     try {
95528       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
95529     } catch (std::out_of_range& e) {
95530       {
95531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95532       };
95533     } catch (std::exception& e) {
95534       {
95535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95536       };
95537     } catch (Dali::DaliException e) {
95538       {
95539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95540       };
95541     } catch (...) {
95542       {
95543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95544       };
95545     }
95546   }
95547
95548   jresult = (void *)result;
95549   return jresult;
95550 }
95551
95552
95553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
95554   void * jresult ;
95555   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95556   Dali::Toolkit::Ruler *result = 0 ;
95557
95558   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95559   {
95560     try {
95561       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
95562     } catch (std::out_of_range& e) {
95563       {
95564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95565       };
95566     } catch (std::exception& e) {
95567       {
95568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95569       };
95570     } catch (Dali::DaliException e) {
95571       {
95572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95573       };
95574     } catch (...) {
95575       {
95576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95577       };
95578     }
95579   }
95580
95581   jresult = (void *)result;
95582   return jresult;
95583 }
95584
95585
95586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
95587   void * jresult ;
95588   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95589   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
95590   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
95591
95592   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95593   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
95594   if (!arg2) {
95595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
95596     return 0;
95597   }
95598   {
95599     try {
95600       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
95601     } catch (std::out_of_range& e) {
95602       {
95603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95604       };
95605     } catch (std::exception& e) {
95606       {
95607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95608       };
95609     } catch (Dali::DaliException e) {
95610       {
95611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95612       };
95613     } catch (...) {
95614       {
95615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95616       };
95617     }
95618   }
95619
95620   jresult = (void *)result;
95621   return jresult;
95622 }
95623
95624
95625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
95626   void * jresult ;
95627   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95628   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
95629   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
95630
95631   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95632   arg2 = (Dali::Toolkit::Ruler *)jarg2;
95633   {
95634     try {
95635       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
95636     } catch (std::out_of_range& e) {
95637       {
95638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95639       };
95640     } catch (std::exception& e) {
95641       {
95642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95643       };
95644     } catch (Dali::DaliException e) {
95645       {
95646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95647       };
95648     } catch (...) {
95649       {
95650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95651       };
95652     }
95653   }
95654
95655   jresult = (void *)result;
95656   return jresult;
95657 }
95658
95659
95660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
95661   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95662
95663   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95664   {
95665     try {
95666       (arg1)->Reset();
95667     } catch (std::out_of_range& e) {
95668       {
95669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95670       };
95671     } catch (std::exception& e) {
95672       {
95673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95674       };
95675     } catch (Dali::DaliException e) {
95676       {
95677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95678       };
95679     } catch (...) {
95680       {
95681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95682       };
95683     }
95684   }
95685
95686 }
95687
95688
95689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
95690   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95691   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
95692
95693   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95694   arg2 = (Dali::Toolkit::Ruler *)jarg2;
95695   {
95696     try {
95697       (arg1)->Reset(arg2);
95698     } catch (std::out_of_range& e) {
95699       {
95700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95701       };
95702     } catch (std::exception& e) {
95703       {
95704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95705       };
95706     } catch (Dali::DaliException e) {
95707       {
95708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95709       };
95710     } catch (...) {
95711       {
95712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95713       };
95714     }
95715   }
95716
95717 }
95718
95719
95720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
95721   void * jresult ;
95722   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95723   Dali::Toolkit::Ruler *result = 0 ;
95724
95725   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95726   {
95727     try {
95728       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
95729     } catch (std::out_of_range& e) {
95730       {
95731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95732       };
95733     } catch (std::exception& e) {
95734       {
95735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95736       };
95737     } catch (Dali::DaliException e) {
95738       {
95739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95740       };
95741     } catch (...) {
95742       {
95743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95744       };
95745     }
95746   }
95747
95748   jresult = (void *)result;
95749   return jresult;
95750 }
95751
95752
95753 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
95754   float jresult ;
95755   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95756   float arg2 ;
95757   float arg3 ;
95758   float result;
95759
95760   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95761   arg2 = (float)jarg2;
95762   arg3 = (float)jarg3;
95763   {
95764     try {
95765       result = (float)(*arg1)->Snap(arg2,arg3);
95766     } catch (std::out_of_range& e) {
95767       {
95768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95769       };
95770     } catch (std::exception& e) {
95771       {
95772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95773       };
95774     } catch (Dali::DaliException e) {
95775       {
95776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95777       };
95778     } catch (...) {
95779       {
95780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95781       };
95782     }
95783   }
95784
95785   jresult = result;
95786   return jresult;
95787 }
95788
95789
95790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
95791   float jresult ;
95792   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95793   float arg2 ;
95794   float result;
95795
95796   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95797   arg2 = (float)jarg2;
95798   {
95799     try {
95800       result = (float)(*arg1)->Snap(arg2);
95801     } catch (std::out_of_range& e) {
95802       {
95803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95804       };
95805     } catch (std::exception& e) {
95806       {
95807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95808       };
95809     } catch (Dali::DaliException e) {
95810       {
95811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95812       };
95813     } catch (...) {
95814       {
95815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95816       };
95817     }
95818   }
95819
95820   jresult = result;
95821   return jresult;
95822 }
95823
95824
95825 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
95826   float jresult ;
95827   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95828   unsigned int arg2 ;
95829   unsigned int *arg3 = 0 ;
95830   bool arg4 ;
95831   float result;
95832
95833   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95834   arg2 = (unsigned int)jarg2;
95835   arg3 = (unsigned int *)jarg3;
95836   arg4 = jarg4 ? true : false;
95837   {
95838     try {
95839       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
95840     } catch (std::out_of_range& e) {
95841       {
95842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95843       };
95844     } catch (std::exception& e) {
95845       {
95846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95847       };
95848     } catch (Dali::DaliException e) {
95849       {
95850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95851       };
95852     } catch (...) {
95853       {
95854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95855       };
95856     }
95857   }
95858
95859   jresult = result;
95860   return jresult;
95861 }
95862
95863
95864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
95865   unsigned int jresult ;
95866   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95867   float arg2 ;
95868   bool arg3 ;
95869   unsigned int result;
95870
95871   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95872   arg2 = (float)jarg2;
95873   arg3 = jarg3 ? true : false;
95874   {
95875     try {
95876       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
95877     } catch (std::out_of_range& e) {
95878       {
95879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95880       };
95881     } catch (std::exception& e) {
95882       {
95883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95884       };
95885     } catch (Dali::DaliException e) {
95886       {
95887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95888       };
95889     } catch (...) {
95890       {
95891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95892       };
95893     }
95894   }
95895
95896   jresult = result;
95897   return jresult;
95898 }
95899
95900
95901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
95902   unsigned int jresult ;
95903   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95904   unsigned int result;
95905
95906   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95907   {
95908     try {
95909       result = (unsigned int)(*arg1)->GetTotalPages();
95910     } catch (std::out_of_range& e) {
95911       {
95912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95913       };
95914     } catch (std::exception& e) {
95915       {
95916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95917       };
95918     } catch (Dali::DaliException e) {
95919       {
95920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95921       };
95922     } catch (...) {
95923       {
95924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95925       };
95926     }
95927   }
95928
95929   jresult = result;
95930   return jresult;
95931 }
95932
95933
95934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
95935   int jresult ;
95936   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95937   Dali::Toolkit::Ruler::RulerType result;
95938
95939   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95940   {
95941     try {
95942       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
95943     } catch (std::out_of_range& e) {
95944       {
95945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95946       };
95947     } catch (std::exception& e) {
95948       {
95949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95950       };
95951     } catch (Dali::DaliException e) {
95952       {
95953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95954       };
95955     } catch (...) {
95956       {
95957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95958       };
95959     }
95960   }
95961
95962   jresult = (int)result;
95963   return jresult;
95964 }
95965
95966
95967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
95968   unsigned int jresult ;
95969   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95970   bool result;
95971
95972   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95973   {
95974     try {
95975       result = (bool)(*arg1)->IsEnabled();
95976     } catch (std::out_of_range& e) {
95977       {
95978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95979       };
95980     } catch (std::exception& e) {
95981       {
95982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95983       };
95984     } catch (Dali::DaliException e) {
95985       {
95986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95987       };
95988     } catch (...) {
95989       {
95990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95991       };
95992     }
95993   }
95994
95995   jresult = result;
95996   return jresult;
95997 }
95998
95999
96000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
96001   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96002
96003   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96004   {
96005     try {
96006       (*arg1)->Enable();
96007     } catch (std::out_of_range& e) {
96008       {
96009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96010       };
96011     } catch (std::exception& e) {
96012       {
96013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96014       };
96015     } catch (Dali::DaliException e) {
96016       {
96017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96018       };
96019     } catch (...) {
96020       {
96021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96022       };
96023     }
96024   }
96025
96026 }
96027
96028
96029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
96030   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96031
96032   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96033   {
96034     try {
96035       (*arg1)->Disable();
96036     } catch (std::out_of_range& e) {
96037       {
96038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96039       };
96040     } catch (std::exception& e) {
96041       {
96042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96043       };
96044     } catch (Dali::DaliException e) {
96045       {
96046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96047       };
96048     } catch (...) {
96049       {
96050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96051       };
96052     }
96053   }
96054
96055 }
96056
96057
96058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
96059   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96060   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
96061   Dali::Toolkit::RulerDomain *argp2 ;
96062
96063   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96064   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
96065   if (!argp2) {
96066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
96067     return ;
96068   }
96069   arg2 = *argp2;
96070   {
96071     try {
96072       (*arg1)->SetDomain(arg2);
96073     } catch (std::out_of_range& e) {
96074       {
96075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96076       };
96077     } catch (std::exception& e) {
96078       {
96079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96080       };
96081     } catch (Dali::DaliException e) {
96082       {
96083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96084       };
96085     } catch (...) {
96086       {
96087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96088       };
96089     }
96090   }
96091
96092 }
96093
96094
96095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
96096   void * jresult ;
96097   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96098   Dali::Toolkit::RulerDomain *result = 0 ;
96099
96100   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96101   {
96102     try {
96103       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
96104     } catch (std::out_of_range& e) {
96105       {
96106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96107       };
96108     } catch (std::exception& e) {
96109       {
96110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96111       };
96112     } catch (Dali::DaliException e) {
96113       {
96114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96115       };
96116     } catch (...) {
96117       {
96118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96119       };
96120     }
96121   }
96122
96123   jresult = (void *)result;
96124   return jresult;
96125 }
96126
96127
96128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
96129   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96130
96131   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96132   {
96133     try {
96134       (*arg1)->DisableDomain();
96135     } catch (std::out_of_range& e) {
96136       {
96137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96138       };
96139     } catch (std::exception& e) {
96140       {
96141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96142       };
96143     } catch (Dali::DaliException e) {
96144       {
96145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96146       };
96147     } catch (...) {
96148       {
96149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96150       };
96151     }
96152   }
96153
96154 }
96155
96156
96157 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
96158   float jresult ;
96159   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96160   float arg2 ;
96161   float arg3 ;
96162   float arg4 ;
96163   float result;
96164
96165   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96166   arg2 = (float)jarg2;
96167   arg3 = (float)jarg3;
96168   arg4 = (float)jarg4;
96169   {
96170     try {
96171       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
96172     } catch (std::out_of_range& e) {
96173       {
96174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96175       };
96176     } catch (std::exception& e) {
96177       {
96178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96179       };
96180     } catch (Dali::DaliException e) {
96181       {
96182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96183       };
96184     } catch (...) {
96185       {
96186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96187       };
96188     }
96189   }
96190
96191   jresult = result;
96192   return jresult;
96193 }
96194
96195
96196 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
96197   float jresult ;
96198   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96199   float arg2 ;
96200   float arg3 ;
96201   float result;
96202
96203   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96204   arg2 = (float)jarg2;
96205   arg3 = (float)jarg3;
96206   {
96207     try {
96208       result = (float)(*arg1)->Clamp(arg2,arg3);
96209     } catch (std::out_of_range& e) {
96210       {
96211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96212       };
96213     } catch (std::exception& e) {
96214       {
96215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96216       };
96217     } catch (Dali::DaliException e) {
96218       {
96219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96220       };
96221     } catch (...) {
96222       {
96223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96224       };
96225     }
96226   }
96227
96228   jresult = result;
96229   return jresult;
96230 }
96231
96232
96233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
96234   float jresult ;
96235   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96236   float arg2 ;
96237   float result;
96238
96239   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96240   arg2 = (float)jarg2;
96241   {
96242     try {
96243       result = (float)(*arg1)->Clamp(arg2);
96244     } catch (std::out_of_range& e) {
96245       {
96246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96247       };
96248     } catch (std::exception& e) {
96249       {
96250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96251       };
96252     } catch (Dali::DaliException e) {
96253       {
96254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96255       };
96256     } catch (...) {
96257       {
96258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96259       };
96260     }
96261   }
96262
96263   jresult = result;
96264   return jresult;
96265 }
96266
96267
96268 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
96269   float jresult ;
96270   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96271   float arg2 ;
96272   float arg3 ;
96273   float arg4 ;
96274   Dali::Toolkit::ClampState *arg5 = 0 ;
96275   float result;
96276
96277   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96278   arg2 = (float)jarg2;
96279   arg3 = (float)jarg3;
96280   arg4 = (float)jarg4;
96281   arg5 = (Dali::Toolkit::ClampState *)jarg5;
96282   if (!arg5) {
96283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
96284     return 0;
96285   }
96286   {
96287     try {
96288       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
96289     } catch (std::out_of_range& e) {
96290       {
96291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96292       };
96293     } catch (std::exception& e) {
96294       {
96295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96296       };
96297     } catch (Dali::DaliException e) {
96298       {
96299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96300       };
96301     } catch (...) {
96302       {
96303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96304       };
96305     }
96306   }
96307
96308   jresult = result;
96309   return jresult;
96310 }
96311
96312
96313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
96314   float jresult ;
96315   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96316   float arg2 ;
96317   float arg3 ;
96318   float arg4 ;
96319   float arg5 ;
96320   float result;
96321
96322   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96323   arg2 = (float)jarg2;
96324   arg3 = (float)jarg3;
96325   arg4 = (float)jarg4;
96326   arg5 = (float)jarg5;
96327   {
96328     try {
96329       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
96330     } catch (std::out_of_range& e) {
96331       {
96332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96333       };
96334     } catch (std::exception& e) {
96335       {
96336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96337       };
96338     } catch (Dali::DaliException e) {
96339       {
96340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96341       };
96342     } catch (...) {
96343       {
96344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96345       };
96346     }
96347   }
96348
96349   jresult = result;
96350   return jresult;
96351 }
96352
96353
96354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
96355   float jresult ;
96356   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96357   float arg2 ;
96358   float arg3 ;
96359   float arg4 ;
96360   float result;
96361
96362   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96363   arg2 = (float)jarg2;
96364   arg3 = (float)jarg3;
96365   arg4 = (float)jarg4;
96366   {
96367     try {
96368       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
96369     } catch (std::out_of_range& e) {
96370       {
96371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96372       };
96373     } catch (std::exception& e) {
96374       {
96375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96376       };
96377     } catch (Dali::DaliException e) {
96378       {
96379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96380       };
96381     } catch (...) {
96382       {
96383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96384       };
96385     }
96386   }
96387
96388   jresult = result;
96389   return jresult;
96390 }
96391
96392
96393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
96394   float jresult ;
96395   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96396   float arg2 ;
96397   float arg3 ;
96398   float result;
96399
96400   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96401   arg2 = (float)jarg2;
96402   arg3 = (float)jarg3;
96403   {
96404     try {
96405       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
96406     } catch (std::out_of_range& e) {
96407       {
96408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96409       };
96410     } catch (std::exception& e) {
96411       {
96412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96413       };
96414     } catch (Dali::DaliException e) {
96415       {
96416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96417       };
96418     } catch (...) {
96419       {
96420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96421       };
96422     }
96423   }
96424
96425   jresult = result;
96426   return jresult;
96427 }
96428
96429
96430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
96431   float jresult ;
96432   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96433   float arg2 ;
96434   float result;
96435
96436   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96437   arg2 = (float)jarg2;
96438   {
96439     try {
96440       result = (float)(*arg1)->SnapAndClamp(arg2);
96441     } catch (std::out_of_range& e) {
96442       {
96443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96444       };
96445     } catch (std::exception& e) {
96446       {
96447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96448       };
96449     } catch (Dali::DaliException e) {
96450       {
96451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96452       };
96453     } catch (...) {
96454       {
96455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96456       };
96457     }
96458   }
96459
96460   jresult = result;
96461   return jresult;
96462 }
96463
96464
96465 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
96466   float jresult ;
96467   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96468   float arg2 ;
96469   float arg3 ;
96470   float arg4 ;
96471   float arg5 ;
96472   Dali::Toolkit::ClampState *arg6 = 0 ;
96473   float result;
96474
96475   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96476   arg2 = (float)jarg2;
96477   arg3 = (float)jarg3;
96478   arg4 = (float)jarg4;
96479   arg5 = (float)jarg5;
96480   arg6 = (Dali::Toolkit::ClampState *)jarg6;
96481   if (!arg6) {
96482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
96483     return 0;
96484   }
96485   {
96486     try {
96487       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
96488     } catch (std::out_of_range& e) {
96489       {
96490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96491       };
96492     } catch (std::exception& e) {
96493       {
96494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96495       };
96496     } catch (Dali::DaliException e) {
96497       {
96498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96499       };
96500     } catch (...) {
96501       {
96502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96503       };
96504     }
96505   }
96506
96507   jresult = result;
96508   return jresult;
96509 }
96510
96511
96512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
96513   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96514
96515   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96516   {
96517     try {
96518       (*arg1)->Reference();
96519     } catch (std::out_of_range& e) {
96520       {
96521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96522       };
96523     } catch (std::exception& e) {
96524       {
96525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96526       };
96527     } catch (Dali::DaliException e) {
96528       {
96529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96530       };
96531     } catch (...) {
96532       {
96533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96534       };
96535     }
96536   }
96537
96538 }
96539
96540
96541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
96542   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96543
96544   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96545   {
96546     try {
96547       (*arg1)->Unreference();
96548     } catch (std::out_of_range& e) {
96549       {
96550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96551       };
96552     } catch (std::exception& e) {
96553       {
96554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96555       };
96556     } catch (Dali::DaliException e) {
96557       {
96558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96559       };
96560     } catch (...) {
96561       {
96562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96563       };
96564     }
96565   }
96566
96567 }
96568
96569
96570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
96571   int jresult ;
96572   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96573   int result;
96574
96575   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96576   {
96577     try {
96578       result = (int)(*arg1)->ReferenceCount();
96579     } catch (std::out_of_range& e) {
96580       {
96581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96582       };
96583     } catch (std::exception& e) {
96584       {
96585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96586       };
96587     } catch (Dali::DaliException e) {
96588       {
96589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96590       };
96591     } catch (...) {
96592       {
96593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96594       };
96595     }
96596   }
96597
96598   jresult = result;
96599   return jresult;
96600 }
96601
96602
96603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
96604   unsigned int jresult ;
96605   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
96606   bool result;
96607
96608   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
96609   {
96610     try {
96611       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
96612     } catch (std::out_of_range& e) {
96613       {
96614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96615       };
96616     } catch (std::exception& e) {
96617       {
96618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96619       };
96620     } catch (Dali::DaliException e) {
96621       {
96622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96623       };
96624     } catch (...) {
96625       {
96626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96627       };
96628     }
96629   }
96630
96631   jresult = result;
96632   return jresult;
96633 }
96634
96635
96636 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
96637   unsigned long jresult ;
96638   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
96639   std::size_t result;
96640
96641   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
96642   {
96643     try {
96644       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
96645     } catch (std::out_of_range& e) {
96646       {
96647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96648       };
96649     } catch (std::exception& e) {
96650       {
96651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96652       };
96653     } catch (Dali::DaliException e) {
96654       {
96655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96656       };
96657     } catch (...) {
96658       {
96659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96660       };
96661     }
96662   }
96663
96664   jresult = (unsigned long)result;
96665   return jresult;
96666 }
96667
96668
96669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
96670   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
96671   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
96672
96673   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
96674   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
96675   {
96676     try {
96677       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
96678     } catch (std::out_of_range& e) {
96679       {
96680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96681       };
96682     } catch (std::exception& e) {
96683       {
96684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96685       };
96686     } catch (Dali::DaliException e) {
96687       {
96688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96689       };
96690     } catch (...) {
96691       {
96692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96693       };
96694     }
96695   }
96696
96697 }
96698
96699
96700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
96701   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
96702   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
96703
96704   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
96705   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
96706   {
96707     try {
96708       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
96709     } catch (std::out_of_range& e) {
96710       {
96711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96712       };
96713     } catch (std::exception& e) {
96714       {
96715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96716       };
96717     } catch (Dali::DaliException e) {
96718       {
96719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96720       };
96721     } catch (...) {
96722       {
96723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96724       };
96725     }
96726   }
96727
96728 }
96729
96730
96731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
96732   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
96733   Dali::Toolkit::Control arg2 ;
96734   Dali::Toolkit::Control *argp2 ;
96735
96736   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
96737   argp2 = (Dali::Toolkit::Control *)jarg2;
96738   if (!argp2) {
96739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
96740     return ;
96741   }
96742   arg2 = *argp2;
96743   {
96744     try {
96745       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
96746     } catch (std::out_of_range& e) {
96747       {
96748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96749       };
96750     } catch (std::exception& e) {
96751       {
96752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96753       };
96754     } catch (Dali::DaliException e) {
96755       {
96756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96757       };
96758     } catch (...) {
96759       {
96760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96761       };
96762     }
96763   }
96764
96765 }
96766
96767
96768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
96769   void * jresult ;
96770   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
96771
96772   {
96773     try {
96774       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
96775     } catch (std::out_of_range& e) {
96776       {
96777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96778       };
96779     } catch (std::exception& e) {
96780       {
96781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96782       };
96783     } catch (Dali::DaliException e) {
96784       {
96785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96786       };
96787     } catch (...) {
96788       {
96789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96790       };
96791     }
96792   }
96793
96794   jresult = (void *)result;
96795   return jresult;
96796 }
96797
96798
96799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
96800   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
96801
96802   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
96803   {
96804     try {
96805       delete arg1;
96806     } catch (std::out_of_range& e) {
96807       {
96808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96809       };
96810     } catch (std::exception& e) {
96811       {
96812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96813       };
96814     } catch (Dali::DaliException e) {
96815       {
96816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96817       };
96818     } catch (...) {
96819       {
96820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96821       };
96822     }
96823   }
96824
96825 }
96826
96827 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
96828   Dali::RefObject *result = NULL;
96829
96830   if (arg1)
96831   {
96832     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
96833   }
96834   return result;
96835 }
96836
96837 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
96838     return (Dali::RefObject *)jarg1;
96839 }
96840
96841 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
96842     return (Dali::SignalObserver *)jarg1;
96843 }
96844
96845 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
96846     return (Dali::ConnectionTrackerInterface *)jarg1;
96847 }
96848
96849 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
96850     return (Dali::BaseHandle *)jarg1;
96851 }
96852
96853 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
96854     return (Dali::BaseHandle *)jarg1;
96855 }
96856
96857 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
96858     return (Dali::BaseHandle *)jarg1;
96859 }
96860
96861 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
96862     return (Dali::BaseHandle *)jarg1;
96863 }
96864
96865 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
96866     return (Dali::BaseHandle *)jarg1;
96867 }
96868
96869 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
96870     return (Dali::BaseHandle *)jarg1;
96871 }
96872
96873 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
96874     return (Dali::BaseHandle *)jarg1;
96875 }
96876
96877 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
96878     return (Dali::BaseHandle *)jarg1;
96879 }
96880
96881 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
96882     return (Dali::BaseHandle *)jarg1;
96883 }
96884
96885 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
96886     return (Dali::BaseHandle *)jarg1;
96887 }
96888
96889 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
96890     return (Dali::BaseHandle *)jarg1;
96891 }
96892
96893 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
96894     return (Dali::BaseHandle *)jarg1;
96895 }
96896
96897 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
96898     return (Dali::Handle *)jarg1;
96899 }
96900
96901 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
96902     return (Dali::Handle *)jarg1;
96903 }
96904
96905 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
96906     return (Dali::BaseHandle *)jarg1;
96907 }
96908
96909 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
96910     return (Dali::BaseHandle *)jarg1;
96911 }
96912
96913 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
96914     return (Dali::Handle *)jarg1;
96915 }
96916
96917 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
96918     return (Dali::BaseHandle *)jarg1;
96919 }
96920
96921 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
96922     return (Dali::Handle *)jarg1;
96923 }
96924
96925 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
96926     return (Dali::GestureDetector *)jarg1;
96927 }
96928
96929 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
96930     return (Dali::Gesture *)jarg1;
96931 }
96932
96933 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
96934     return (Dali::Handle *)jarg1;
96935 }
96936
96937 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
96938     return (Dali::Actor *)jarg1;
96939 }
96940
96941 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
96942     return (Dali::BaseHandle *)jarg1;
96943 }
96944
96945 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
96946     return (Dali::RefObject *)jarg1;
96947 }
96948
96949 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
96950     return (Dali::Actor *)jarg1;
96951 }
96952
96953 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
96954     return (Dali::GestureDetector *)jarg1;
96955 }
96956
96957 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
96958     return (Dali::Gesture *)jarg1;
96959 }
96960
96961 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
96962     return (Dali::GestureDetector *)jarg1;
96963 }
96964
96965 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
96966     return (Dali::Gesture *)jarg1;
96967 }
96968
96969 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
96970     return (Dali::GestureDetector *)jarg1;
96971 }
96972
96973 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
96974     return (Dali::Gesture *)jarg1;
96975 }
96976
96977 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
96978     return (Dali::BaseHandle *)jarg1;
96979 }
96980
96981 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
96982     return (Dali::Handle *)jarg1;
96983 }
96984
96985 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
96986     return (Dali::Handle *)jarg1;
96987 }
96988
96989 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
96990     return (Dali::Handle *)jarg1;
96991 }
96992
96993 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
96994     return (Dali::RefObject *)jarg1;
96995 }
96996
96997 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
96998     return (Dali::Actor *)jarg1;
96999 }
97000
97001 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
97002     return (Dali::BaseHandle *)jarg1;
97003 }
97004
97005 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
97006     return (Dali::BaseHandle *)jarg1;
97007 }
97008
97009 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
97010     return (Dali::BaseHandle *)jarg1;
97011 }
97012
97013 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
97014     return (Dali::CustomActorImpl *)jarg1;
97015 }
97016
97017 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
97018     return (Dali::CustomActor *)jarg1;
97019 }
97020
97021 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
97022     return (Dali::BaseHandle *)jarg1;
97023 }
97024
97025 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
97026     return (Dali::Toolkit::Control *)jarg1;
97027 }
97028
97029 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
97030     return (Dali::Toolkit::Control *)jarg1;
97031 }
97032
97033 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
97034     return (Dali::Toolkit::Button *)jarg1;
97035 }
97036
97037 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
97038     return (Dali::Toolkit::Button *)jarg1;
97039 }
97040
97041 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
97042     return (Dali::Toolkit::Button *)jarg1;
97043 }
97044
97045 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
97046     return (Dali::Toolkit::Control *)jarg1;
97047 }
97048
97049 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
97050     return (Dali::Toolkit::Control *)jarg1;
97051 }
97052
97053 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
97054     return (Dali::Toolkit::Control *)jarg1;
97055 }
97056
97057 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
97058     return (Dali::Toolkit::Control *)jarg1;
97059 }
97060
97061 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
97062     return (Dali::Toolkit::Control *)jarg1;
97063 }
97064
97065 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
97066     return (Dali::RefObject *)jarg1;
97067 }
97068
97069 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
97070     return (Dali::Toolkit::Scrollable *)jarg1;
97071 }
97072
97073 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
97074     return (Dali::BaseHandle *)jarg1;
97075 }
97076
97077 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
97078     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
97079 }
97080
97081 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
97082     return (Dali::RefObject *)jarg1;
97083 }
97084
97085 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
97086     return (Dali::Toolkit::Ruler *)jarg1;
97087 }
97088
97089 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
97090     return (Dali::Toolkit::Ruler *)jarg1;
97091 }
97092
97093 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
97094     return (Dali::Toolkit::Scrollable *)jarg1;
97095 }
97096
97097 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
97098     return (Dali::Toolkit::Control *)jarg1;
97099 }
97100
97101
97102 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
97103     return (Dali::Toolkit::Control *)jarg1;
97104 }
97105
97106 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
97107     return (Dali::BaseHandle *)jarg1;
97108 }
97109
97110 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
97111     return (Dali::BaseHandle *)jarg1;
97112 }
97113
97114 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
97115     return (Dali::Toolkit::Control *)jarg1;
97116 }
97117
97118 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
97119     return (Dali::Toolkit::Control *)jarg1;
97120 }
97121
97122 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
97123     return (Dali::Toolkit::Control *)jarg1;
97124 }
97125
97126 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
97127     return (Dali::Toolkit::Control *)jarg1;
97128 }
97129
97130 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
97131     return (Dali::Toolkit::Control *)jarg1;
97132 }
97133
97134 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
97135     return (Dali::Toolkit::Control *)jarg1;
97136 }
97137
97138 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
97139     return (Dali::Toolkit::PageTurnView *)jarg1;
97140 }
97141
97142 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
97143     return (Dali::Toolkit::PageTurnView *)jarg1;
97144 }
97145
97146 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
97147     return (Dali::Toolkit::Button *)jarg1;
97148 }
97149
97150 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
97151     return (Dali::BaseHandle *)jarg1;
97152 }
97153
97154 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
97155     return (Dali::BaseHandle *)jarg1;
97156 }
97157
97158 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
97159     return (Dali::BaseHandle *)jarg1;
97160 }
97161
97162 /*
97163  * Widget binding
97164  */
97165 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
97166     return (Dali::BaseHandle *)jarg1;
97167 }
97168
97169 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
97170     return (Dali::BaseObject *)jarg1;
97171 }
97172
97173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
97174   void * jresult ;
97175   Dali::Widget result;
97176
97177   {
97178     try {
97179       result = Dali::Widget::New();
97180     } catch (std::out_of_range& e) {
97181       {
97182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97183       };
97184     } catch (std::exception& e) {
97185       {
97186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97187       };
97188     } catch (...) {
97189       {
97190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97191       };
97192     }
97193   }
97194   jresult = new Dali::Widget((const Dali::Widget &)result);
97195   return jresult;
97196 }
97197
97198
97199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
97200   void * jresult ;
97201   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
97202   Dali::Widget result;
97203
97204   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97205
97206   if (!arg1) {
97207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
97208     return 0;
97209   }
97210   {
97211     try {
97212       jresult = new Dali::Widget(arg1);
97213     } catch (std::out_of_range& e) {
97214       {
97215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97216       };
97217     } catch (std::exception& e) {
97218       {
97219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97220       };
97221     } catch (...) {
97222       {
97223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97224       };
97225     }
97226   }
97227   return jresult;
97228 }
97229
97230
97231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
97232   void * jresult ;
97233   Dali::Widget *result = 0 ;
97234
97235   {
97236     try {
97237       result = (Dali::Widget *)new Dali::Widget();
97238     } catch (std::out_of_range& e) {
97239       {
97240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97241       };
97242     } catch (std::exception& e) {
97243       {
97244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97245       };
97246     } catch (...) {
97247       {
97248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97249       };
97250     }
97251   }
97252   jresult = (void *)result;
97253   return jresult;
97254 }
97255
97256
97257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
97258   void * jresult ;
97259   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
97260   Dali::Widget *arg2 = 0 ;
97261   Dali::Widget *result = 0 ;
97262
97263   arg1 = (Dali::Widget *)jarg1;
97264   arg2 = (Dali::Widget *)jarg2;
97265   if (!arg2) {
97266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
97267     return 0;
97268   }
97269   {
97270     try {
97271       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
97272     } catch (std::out_of_range& e) {
97273       {
97274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97275       };
97276     } catch (std::exception& e) {
97277       {
97278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97279       };
97280     } catch (...) {
97281       {
97282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97283       };
97284     }
97285   }
97286   jresult = (void *)result;
97287   return jresult;
97288 }
97289
97290
97291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
97292   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
97293
97294   arg1 = (Dali::Widget *)jarg1;
97295   {
97296     try {
97297       delete arg1;
97298     } catch (std::out_of_range& e) {
97299       {
97300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97301       };
97302     } catch (std::exception& e) {
97303       {
97304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97305       };
97306     } catch (...) {
97307       {
97308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97309       };
97310     }
97311   }
97312 }
97313
97314
97315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
97316   void * jresult ;
97317   SwigDirector_WidgetImpl* result;
97318   {
97319     try {
97320       result = new SwigDirector_WidgetImpl();
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 (...) {
97330       {
97331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97332       };
97333     }
97334   }
97335   jresult = result;
97336   return jresult;
97337 }
97338
97339
97340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
97341   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97342   std::string *arg2 = 0 ;
97343   Dali::Window arg3 ;
97344   Dali::Window *argp3 ;
97345
97346   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97347   if (!jarg2) {
97348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97349     return ;
97350   }
97351   std::string arg2_str(jarg2);
97352   arg2 = &arg2_str;
97353   argp3 = (Dali::Window *)jarg3;
97354   if (!argp3) {
97355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
97356     return ;
97357   }
97358   arg3 = *argp3;
97359   {
97360     try {
97361       (arg1)->OnCreate((std::string const &)*arg2,arg3);
97362     } catch (std::out_of_range& e) {
97363       {
97364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97365       };
97366     } catch (std::exception& e) {
97367       {
97368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97369       };
97370     } catch (...) {
97371       {
97372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97373       };
97374     }
97375   }
97376 }
97377
97378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
97379   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97380   std::string *arg2 = 0 ;
97381   Dali::Window arg3 ;
97382   Dali::Window *argp3 ;
97383
97384   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97385   if (!jarg2) {
97386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97387     return ;
97388   }
97389   std::string arg2_str(jarg2);
97390   arg2 = &arg2_str;
97391   argp3 = (Dali::Window *)jarg3;
97392   if (!argp3) {
97393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
97394     return ;
97395   }
97396   arg3 = *argp3;
97397   {
97398     try {
97399       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
97400     } catch (std::out_of_range& e) {
97401       {
97402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97403       };
97404     } catch (std::exception& e) {
97405       {
97406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97407       };
97408     } catch (...) {
97409       {
97410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97411       };
97412     }
97413   }
97414 }
97415
97416
97417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
97418   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97419   std::string *arg2 = 0 ;
97420   Dali::Widget::Termination arg3 ;
97421
97422   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97423   if (!jarg2) {
97424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97425     return ;
97426   }
97427   std::string arg2_str(jarg2);
97428   arg2 = &arg2_str;
97429   arg3 = (Dali::Widget::Termination)jarg3;
97430   {
97431     try {
97432       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
97433     } catch (std::out_of_range& e) {
97434       {
97435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97436       };
97437     } catch (std::exception& e) {
97438       {
97439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97440       };
97441     } catch (...) {
97442       {
97443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97444       };
97445     }
97446   }
97447 }
97448
97449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
97450   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97451   std::string *arg2 = 0 ;
97452   Dali::Widget::Termination arg3 ;
97453
97454   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97455   if (!jarg2) {
97456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97457     return ;
97458   }
97459   std::string arg2_str(jarg2);
97460   arg2 = &arg2_str;
97461   arg3 = (Dali::Widget::Termination)jarg3;
97462   {
97463     try {
97464       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
97465     } catch (std::out_of_range& e) {
97466       {
97467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97468       };
97469     } catch (std::exception& e) {
97470       {
97471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97472       };
97473     } catch (...) {
97474       {
97475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97476       };
97477     }
97478   }
97479 }
97480
97481
97482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
97483   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97484
97485   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97486   {
97487     try {
97488       (arg1)->OnPause();
97489     } catch (std::out_of_range& e) {
97490       {
97491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97492       };
97493     } catch (std::exception& e) {
97494       {
97495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97496       };
97497     } catch (...) {
97498       {
97499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97500       };
97501     }
97502   }
97503 }
97504
97505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
97506   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97507
97508   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97509   {
97510     try {
97511       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
97512     } catch (std::out_of_range& e) {
97513       {
97514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97515       };
97516     } catch (std::exception& e) {
97517       {
97518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97519       };
97520     } catch (...) {
97521       {
97522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97523       };
97524     }
97525   }
97526 }
97527
97528
97529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
97530   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97531
97532   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97533   {
97534     try {
97535       (arg1)->OnResume();
97536     } catch (std::out_of_range& e) {
97537       {
97538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97539       };
97540     } catch (std::exception& e) {
97541       {
97542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97543       };
97544     } catch (...) {
97545       {
97546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97547       };
97548     }
97549   }
97550 }
97551
97552
97553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
97554   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97555
97556   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97557   {
97558     try {
97559       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
97560     } catch (std::out_of_range& e) {
97561       {
97562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97563       };
97564     } catch (std::exception& e) {
97565       {
97566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97567       };
97568     } catch (...) {
97569       {
97570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97571       };
97572     }
97573   }
97574 }
97575
97576
97577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
97578   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97579   Dali::Window arg2 ;
97580   Dali::Window *argp2 ;
97581
97582   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97583   argp2 = (Dali::Window *)jarg2;
97584   if (!argp2) {
97585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
97586     return ;
97587   }
97588   arg2 = *argp2;
97589   {
97590     try {
97591       (arg1)->OnResize(arg2);
97592     } catch (std::out_of_range& e) {
97593       {
97594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97595       };
97596     } catch (std::exception& e) {
97597       {
97598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97599       };
97600     } catch (...) {
97601       {
97602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97603       };
97604     }
97605   }
97606 }
97607
97608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
97609   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97610   Dali::Window arg2 ;
97611   Dali::Window *argp2 ;
97612
97613   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97614   argp2 = (Dali::Window *)jarg2;
97615   if (!argp2) {
97616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
97617     return ;
97618   }
97619   arg2 = *argp2;
97620   {
97621     try {
97622       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
97623     } catch (std::out_of_range& e) {
97624       {
97625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97626       };
97627     } catch (std::exception& e) {
97628       {
97629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97630       };
97631     } catch (...) {
97632       {
97633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97634       };
97635     }
97636   }
97637 }
97638
97639
97640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
97641   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97642   std::string *arg2 = 0 ;
97643   int arg3 ;
97644
97645   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97646   if (!jarg2) {
97647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97648     return ;
97649   }
97650   std::string arg2_str(jarg2);
97651   arg2 = &arg2_str;
97652   arg3 = (int)jarg3;
97653   {
97654     try {
97655       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
97656     } catch (std::out_of_range& e) {
97657       {
97658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97659       };
97660     } catch (std::exception& e) {
97661       {
97662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97663       };
97664     } catch (...) {
97665       {
97666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97667       };
97668     }
97669   }
97670 }
97671
97672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
97673   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97674   std::string *arg2 = 0 ;
97675   int arg3 ;
97676
97677   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97678   if (!jarg2) {
97679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97680     return ;
97681   }
97682   std::string arg2_str(jarg2);
97683   arg2 = &arg2_str;
97684   arg3 = (int)jarg3;
97685   {
97686     try {
97687       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
97688     } catch (std::out_of_range& e) {
97689       {
97690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97691       };
97692     } catch (std::exception& e) {
97693       {
97694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97695       };
97696     } catch (...) {
97697       {
97698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97699       };
97700     }
97701   }
97702 }
97703
97704
97705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
97706   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97707   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
97708   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
97709
97710   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97711   arg2 = (Dali::SlotObserver *)jarg2;
97712   arg3 = (Dali::CallbackBase *)jarg3;
97713   {
97714     try {
97715       (arg1)->SignalConnected(arg2,arg3);
97716     } catch (std::out_of_range& e) {
97717       {
97718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97719       };
97720     } catch (std::exception& e) {
97721       {
97722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97723       };
97724     } catch (...) {
97725       {
97726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97727       };
97728     }
97729   }
97730 }
97731
97732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
97733   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97734   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
97735   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
97736
97737   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97738   arg2 = (Dali::SlotObserver *)jarg2;
97739   arg3 = (Dali::CallbackBase *)jarg3;
97740   {
97741     try {
97742       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
97743     } catch (std::out_of_range& e) {
97744       {
97745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97746       };
97747     } catch (std::exception& e) {
97748       {
97749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97750       };
97751     } catch (...) {
97752       {
97753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97754       };
97755     }
97756   }
97757 }
97758
97759
97760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
97761   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97762   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
97763   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
97764
97765   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97766   arg2 = (Dali::SlotObserver *)jarg2;
97767   arg3 = (Dali::CallbackBase *)jarg3;
97768   {
97769     try {
97770       (arg1)->SignalDisconnected(arg2,arg3);
97771     } catch (std::out_of_range& e) {
97772       {
97773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97774       };
97775     } catch (std::exception& e) {
97776       {
97777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97778       };
97779     } catch (...) {
97780       {
97781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97782       };
97783     }
97784   }
97785 }
97786
97787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
97788   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97789   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
97790   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
97791
97792   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97793   arg2 = (Dali::SlotObserver *)jarg2;
97794   arg3 = (Dali::CallbackBase *)jarg3;
97795   {
97796     try {
97797       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
97798     } catch (std::out_of_range& e) {
97799       {
97800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97801       };
97802     } catch (std::exception& e) {
97803       {
97804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97805       };
97806     } catch (...) {
97807       {
97808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97809       };
97810     }
97811   }
97812 }
97813
97814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
97815   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97816   std::string *arg2 = 0 ;
97817
97818   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97819   if (!jarg2) {
97820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97821     return ;
97822   }
97823   std::string arg2_str(jarg2);
97824   arg2 = &arg2_str;
97825   {
97826     try {
97827       (arg1)->SetContentInfo((std::string const &)*arg2);
97828     } catch (std::out_of_range& e) {
97829       {
97830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97831       };
97832     } catch (std::exception& e) {
97833       {
97834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97835       };
97836     } catch (...) {
97837       {
97838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97839       };
97840     }
97841   }
97842 }
97843
97844
97845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
97846   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
97847   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
97848
97849   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97850   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
97851   {
97852     try {
97853       (arg1)->SetImpl(arg2);
97854     } catch (std::out_of_range& e) {
97855       {
97856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97857       };
97858     } catch (std::exception& e) {
97859       {
97860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97861       };
97862     } catch (...) {
97863       {
97864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97865       };
97866     }
97867   }
97868 }
97869
97870 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) {
97871
97872   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
97873   if (director) {
97874     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
97875   }
97876 }
97877
97878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
97879   void * jresult ;
97880   Dali::Widget *arg1 = 0 ;
97881   SwigDirector_WidgetImpl *result = 0 ;
97882
97883   arg1 = (Dali::Widget *)jarg1;
97884   if (!arg1) {
97885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
97886     return 0;
97887   }
97888   {
97889     try {
97890       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
97891     } catch (std::out_of_range& e) {
97892       {
97893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97894       };
97895     } catch (std::exception& e) {
97896       {
97897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97898       };
97899     } catch (...) {
97900       {
97901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97902       };
97903     }
97904   }
97905
97906   jresult = (void *)result;
97907   return jresult;
97908 }
97909
97910
97911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
97912   void * jresult ;
97913   int *arg1 = (int *) 0 ;
97914   char ***arg2 ;
97915   std::string *arg3 = 0 ;
97916   Dali::WidgetApplication result;
97917   {
97918     int index = 0;
97919     int length = 0;
97920     char *retPtr;
97921     char *nextPtr;
97922     argWidgetC = jarg1;
97923     argWidgetV = new char*[jarg1 + 1];
97924
97925     retPtr = strtok_r( jarg2, " ", &nextPtr);
97926     if( retPtr )
97927     {
97928       length = strlen(retPtr);
97929     }
97930     argWidgetV[index] = new char[length + 1];
97931     if( retPtr )
97932     {
97933       strncpy(argWidgetV[index], retPtr, length);
97934     }
97935     argWidgetV[index][length] = '\0';
97936     index++;
97937
97938     while (index < jarg1)
97939     {
97940       length = 0;
97941       retPtr = strtok_r(NULL, " ", &nextPtr);
97942       if( retPtr )
97943       {
97944         length = strlen(retPtr);
97945       }
97946       argWidgetV[index] = new char[length + 1];
97947       if( retPtr )
97948       {
97949         strncpy(argWidgetV[index], retPtr, length);
97950       }
97951       argWidgetV[index][length] = '\0';
97952       index++;
97953     }
97954
97955     argWidgetV[jarg1] = NULL;
97956     argWidgetC = jarg1;
97957
97958     arg1 = &argWidgetC;
97959     arg2 = &argWidgetV;
97960   }
97961
97962   if (!jarg3) {
97963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97964     return 0;
97965   }
97966   std::string arg3_str(jarg3);
97967   arg3 = &arg3_str;
97968   {
97969     try {
97970       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
97971     } catch (std::out_of_range& e) {
97972       {
97973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97974       };
97975     } catch (std::exception& e) {
97976       {
97977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97978       };
97979     } catch (...) {
97980       {
97981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97982       };
97983     }
97984   }
97985   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
97986
97987   return jresult;
97988 }
97989
97990
97991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
97992   void * jresult ;
97993   Dali::WidgetApplication *result = 0 ;
97994
97995   {
97996     try {
97997       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
97998     } catch (std::out_of_range& e) {
97999       {
98000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98001       };
98002     } catch (std::exception& e) {
98003       {
98004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98005       };
98006     } catch (...) {
98007       {
98008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98009       };
98010     }
98011   }
98012   jresult = (void *)result;
98013   return jresult;
98014 }
98015
98016
98017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
98018   void * jresult ;
98019   Dali::WidgetApplication *arg1 = 0 ;
98020   Dali::WidgetApplication *result = 0 ;
98021
98022   arg1 = (Dali::WidgetApplication *)jarg1;
98023   if (!arg1) {
98024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
98025     return 0;
98026   }
98027   {
98028     try {
98029       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
98030     } catch (std::out_of_range& e) {
98031       {
98032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98033       };
98034     } catch (std::exception& e) {
98035       {
98036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98037       };
98038     } catch (...) {
98039       {
98040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98041       };
98042     }
98043   }
98044   jresult = (void *)result;
98045   return jresult;
98046 }
98047
98048
98049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
98050   void * jresult ;
98051   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
98052   Dali::WidgetApplication *arg2 = 0 ;
98053   Dali::WidgetApplication *result = 0 ;
98054
98055   arg1 = (Dali::WidgetApplication *)jarg1;
98056   arg2 = (Dali::WidgetApplication *)jarg2;
98057   if (!arg2) {
98058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
98059     return 0;
98060   }
98061   {
98062     try {
98063       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
98064     } catch (std::out_of_range& e) {
98065       {
98066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98067       };
98068     } catch (std::exception& e) {
98069       {
98070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98071       };
98072     } catch (...) {
98073       {
98074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98075       };
98076     }
98077   }
98078   jresult = (void *)result;
98079   return jresult;
98080 }
98081
98082
98083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
98084   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
98085
98086   arg1 = (Dali::WidgetApplication *)jarg1;
98087   {
98088     try {
98089       delete arg1;
98090       if( argWidgetV )
98091       {
98092         // free string data
98093         for( int i=0; i < argWidgetC+1; i++)
98094         {
98095           delete [] argWidgetV[i];
98096         }
98097         delete [] argWidgetV;
98098       }
98099     } catch (std::out_of_range& e) {
98100       {
98101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98102       };
98103     } catch (std::exception& e) {
98104       {
98105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98106       };
98107     } catch (...) {
98108       {
98109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98110       };
98111     }
98112   }
98113 }
98114
98115
98116 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
98117 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
98118
98119 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
98120 {
98121   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
98122   return *widget;
98123 }
98124
98125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
98126   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
98127   std::string *arg2 = 0 ;
98128
98129   arg1 = (Dali::WidgetApplication *)jarg1;
98130   if (!jarg2) {
98131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98132     return ;
98133   }
98134   std::string arg2_str(*jarg2);
98135   arg2 = &arg2_str;
98136
98137   if(!_CSharpCreateWidgetFunction)
98138   {
98139     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
98140   }
98141
98142   {
98143     try {
98144       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
98145     } catch (std::out_of_range& e) {
98146       {
98147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98148       };
98149     } catch (std::exception& e) {
98150       {
98151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98152       };
98153     } catch (...) {
98154       {
98155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98156       };
98157     }
98158   }
98159
98160   //Typemap argout in c++ file.
98161   //This will convert c++ string to c# string
98162   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
98163 }
98164
98165
98166 //for PixelBuffer and ImageLoading
98167
98168 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
98169     return (Dali::BaseHandle *)jarg1;
98170 }
98171
98172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
98173   void * jresult ;
98174   unsigned int arg1 ;
98175   unsigned int arg2 ;
98176   Dali::Pixel::Format arg3 ;
98177   Dali::Devel::PixelBuffer result;
98178
98179   arg1 = (unsigned int)jarg1;
98180   arg2 = (unsigned int)jarg2;
98181   arg3 = (Dali::Pixel::Format)jarg3;
98182   {
98183     try {
98184       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
98185     } catch (std::out_of_range& e) {
98186       {
98187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98188       };
98189     } catch (std::exception& e) {
98190       {
98191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98192       };
98193     } catch (...) {
98194       {
98195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98196       };
98197     }
98198   }
98199   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98200   return jresult;
98201 }
98202
98203
98204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
98205   void * jresult ;
98206   Dali::Devel::PixelBuffer *result = 0 ;
98207
98208   {
98209     try {
98210       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
98211     } catch (std::out_of_range& e) {
98212       {
98213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98214       };
98215     } catch (std::exception& e) {
98216       {
98217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98218       };
98219     } catch (...) {
98220       {
98221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98222       };
98223     }
98224   }
98225   jresult = (void *)result;
98226   return jresult;
98227 }
98228
98229
98230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
98231   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
98232
98233   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98234   {
98235     try {
98236       delete arg1;
98237     } catch (std::out_of_range& e) {
98238       {
98239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98240       };
98241     } catch (std::exception& e) {
98242       {
98243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98244       };
98245     } catch (...) {
98246       {
98247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98248       };
98249     }
98250   }
98251 }
98252
98253
98254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
98255   void * jresult ;
98256   Dali::Devel::PixelBuffer *arg1 = 0 ;
98257   Dali::Devel::PixelBuffer *result = 0 ;
98258
98259   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98260   if (!arg1) {
98261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
98262     return 0;
98263   }
98264   {
98265     try {
98266       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
98267     } catch (std::out_of_range& e) {
98268       {
98269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98270       };
98271     } catch (std::exception& e) {
98272       {
98273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98274       };
98275     } catch (...) {
98276       {
98277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98278       };
98279     }
98280   }
98281   jresult = (void *)result;
98282   return jresult;
98283 }
98284
98285
98286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
98287   void * jresult ;
98288   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
98289   Dali::Devel::PixelBuffer *arg2 = 0 ;
98290   Dali::Devel::PixelBuffer *result = 0 ;
98291
98292   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98293   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
98294   if (!arg2) {
98295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
98296     return 0;
98297   }
98298   {
98299     try {
98300       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
98301     } catch (std::out_of_range& e) {
98302       {
98303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98304       };
98305     } catch (std::exception& e) {
98306       {
98307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98308       };
98309     } catch (...) {
98310       {
98311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98312       };
98313     }
98314   }
98315   jresult = (void *)result;
98316   return jresult;
98317 }
98318
98319
98320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
98321   void * jresult ;
98322   Dali::Devel::PixelBuffer *arg1 = 0 ;
98323   Dali::PixelData result;
98324
98325   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98326   if (!arg1) {
98327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
98328     return 0;
98329   }
98330   {
98331     try {
98332       result = Dali::Devel::PixelBuffer::Convert(*arg1);
98333     } catch (std::out_of_range& e) {
98334       {
98335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98336       };
98337     } catch (std::exception& e) {
98338       {
98339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98340       };
98341     } catch (...) {
98342       {
98343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98344       };
98345     }
98346   }
98347   jresult = new Dali::PixelData((const Dali::PixelData &)result);
98348   return jresult;
98349 }
98350
98351
98352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
98353   void * jresult ;
98354   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
98355   Dali::PixelData result;
98356
98357   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98358   {
98359     try {
98360       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
98361     } catch (std::out_of_range& e) {
98362       {
98363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98364       };
98365     } catch (std::exception& e) {
98366       {
98367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98368       };
98369     } catch (...) {
98370       {
98371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98372       };
98373     }
98374   }
98375   jresult = new Dali::PixelData((const Dali::PixelData &)result);
98376   return jresult;
98377 }
98378
98379
98380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
98381   void * jresult ;
98382   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
98383   unsigned char *result = 0 ;
98384
98385   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98386   {
98387     try {
98388       result = (unsigned char *)(arg1)->GetBuffer();
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 (...) {
98398       {
98399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98400       };
98401     }
98402   }
98403   jresult = (void *)result;
98404   return jresult;
98405 }
98406
98407
98408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
98409   unsigned int jresult ;
98410   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
98411   unsigned int result;
98412
98413   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98414   {
98415     try {
98416       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
98417     } catch (std::out_of_range& e) {
98418       {
98419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98420       };
98421     } catch (std::exception& e) {
98422       {
98423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98424       };
98425     } catch (...) {
98426       {
98427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98428       };
98429     }
98430   }
98431   jresult = result;
98432   return jresult;
98433 }
98434
98435
98436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
98437   unsigned int jresult ;
98438   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
98439   unsigned int result;
98440
98441   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98442   {
98443     try {
98444       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
98445     } catch (std::out_of_range& e) {
98446       {
98447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98448       };
98449     } catch (std::exception& e) {
98450       {
98451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98452       };
98453     } catch (...) {
98454       {
98455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98456       };
98457     }
98458   }
98459   jresult = result;
98460   return jresult;
98461 }
98462
98463
98464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
98465   int jresult ;
98466   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
98467   Dali::Pixel::Format result;
98468
98469   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98470   {
98471     try {
98472       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
98473     } catch (std::out_of_range& e) {
98474       {
98475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98476       };
98477     } catch (std::exception& e) {
98478       {
98479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98480       };
98481     } catch (...) {
98482       {
98483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98484       };
98485     }
98486   }
98487   jresult = (int)result;
98488   return jresult;
98489 }
98490
98491
98492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
98493   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
98494   Dali::Devel::PixelBuffer arg2 ;
98495   float arg3 ;
98496   bool arg4 ;
98497   Dali::Devel::PixelBuffer *argp2 ;
98498
98499   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98500   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
98501   if (!argp2) {
98502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
98503     return ;
98504   }
98505   arg2 = *argp2;
98506   arg3 = (float)jarg3;
98507   arg4 = jarg4 ? true : false;
98508   {
98509     try {
98510       (arg1)->ApplyMask(arg2,arg3,arg4);
98511     } catch (std::out_of_range& e) {
98512       {
98513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98514       };
98515     } catch (std::exception& e) {
98516       {
98517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98518       };
98519     } catch (...) {
98520       {
98521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98522       };
98523     }
98524   }
98525 }
98526
98527
98528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
98529   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
98530   Dali::Devel::PixelBuffer arg2 ;
98531   float arg3 ;
98532   Dali::Devel::PixelBuffer *argp2 ;
98533
98534   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98535   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
98536   if (!argp2) {
98537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
98538     return ;
98539   }
98540   arg2 = *argp2;
98541   arg3 = (float)jarg3;
98542   {
98543     try {
98544       (arg1)->ApplyMask(arg2,arg3);
98545     } catch (std::out_of_range& e) {
98546       {
98547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98548       };
98549     } catch (std::exception& e) {
98550       {
98551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98552       };
98553     } catch (...) {
98554       {
98555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98556       };
98557     }
98558   }
98559 }
98560
98561
98562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
98563   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
98564   Dali::Devel::PixelBuffer arg2 ;
98565   Dali::Devel::PixelBuffer *argp2 ;
98566
98567   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98568   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
98569   if (!argp2) {
98570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
98571     return ;
98572   }
98573   arg2 = *argp2;
98574   {
98575     try {
98576       (arg1)->ApplyMask(arg2);
98577     } catch (std::out_of_range& e) {
98578       {
98579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98580       };
98581     } catch (std::exception& e) {
98582       {
98583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98584       };
98585     } catch (...) {
98586       {
98587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98588       };
98589     }
98590   }
98591 }
98592
98593
98594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
98595   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
98596   float arg2 ;
98597
98598   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98599   arg2 = (float)jarg2;
98600   {
98601     try {
98602       (arg1)->ApplyGaussianBlur(arg2);
98603     } catch (std::out_of_range& e) {
98604       {
98605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98606       };
98607     } catch (std::exception& e) {
98608       {
98609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98610       };
98611     } catch (...) {
98612       {
98613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98614       };
98615     }
98616   }
98617 }
98618
98619
98620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
98621   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
98622   uint16_t arg2 ;
98623   uint16_t arg3 ;
98624   uint16_t arg4 ;
98625   uint16_t arg5 ;
98626
98627   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98628   arg2 = (uint16_t)jarg2;
98629   arg3 = (uint16_t)jarg3;
98630   arg4 = (uint16_t)jarg4;
98631   arg5 = (uint16_t)jarg5;
98632   {
98633     try {
98634       (arg1)->Crop(arg2,arg3,arg4,arg5);
98635     } catch (std::out_of_range& e) {
98636       {
98637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98638       };
98639     } catch (std::exception& e) {
98640       {
98641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98642       };
98643     } catch (...) {
98644       {
98645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98646       };
98647     }
98648   }
98649 }
98650
98651
98652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
98653   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
98654   uint16_t arg2 ;
98655   uint16_t arg3 ;
98656
98657   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98658   arg2 = (uint16_t)jarg2;
98659   arg3 = (uint16_t)jarg3;
98660   {
98661     try {
98662       (arg1)->Resize(arg2,arg3);
98663     } catch (std::out_of_range& e) {
98664       {
98665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98666       };
98667     } catch (std::exception& e) {
98668       {
98669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98670       };
98671     } catch (...) {
98672       {
98673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98674       };
98675     }
98676   }
98677 }
98678
98679 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
98680   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
98681   Dali::Degree * arg2 ;
98682
98683   bool result = false;
98684
98685   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98686   arg2 = (Dali::Degree *)jarg2;
98687   {
98688     try {
98689       result = (arg1)->Rotate(*arg2);
98690     } catch (std::out_of_range& e) {
98691       {
98692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98693       };
98694     } catch (std::exception& e) {
98695       {
98696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98697       };
98698     } catch (...) {
98699       {
98700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98701       };
98702     }
98703   }
98704   return result;
98705 }
98706
98707
98708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
98709   void * jresult ;
98710   std::string *arg1 = 0 ;
98711   Dali::ImageDimensions arg2 ;
98712   Dali::FittingMode::Type arg3 ;
98713   Dali::SamplingMode::Type arg4 ;
98714   bool arg5 ;
98715   Dali::ImageDimensions *argp2 ;
98716   Dali::Devel::PixelBuffer result;
98717
98718   if (!jarg1) {
98719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98720     return 0;
98721   }
98722   std::string arg1_str(jarg1);
98723   arg1 = &arg1_str;
98724   argp2 = (Dali::ImageDimensions *)jarg2;
98725   if (!argp2) {
98726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98727     return 0;
98728   }
98729   arg2 = *argp2;
98730   arg3 = (Dali::FittingMode::Type)jarg3;
98731   arg4 = (Dali::SamplingMode::Type)jarg4;
98732   arg5 = jarg5 ? true : false;
98733   {
98734     try {
98735       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
98736     } catch (std::out_of_range& e) {
98737       {
98738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98739       };
98740     } catch (std::exception& e) {
98741       {
98742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98743       };
98744     } catch (...) {
98745       {
98746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98747       };
98748     }
98749   }
98750   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98751
98752   return jresult;
98753 }
98754
98755
98756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
98757   void * jresult ;
98758   std::string *arg1 = 0 ;
98759   Dali::ImageDimensions arg2 ;
98760   Dali::FittingMode::Type arg3 ;
98761   Dali::SamplingMode::Type arg4 ;
98762   Dali::ImageDimensions *argp2 ;
98763   Dali::Devel::PixelBuffer result;
98764
98765   if (!jarg1) {
98766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98767     return 0;
98768   }
98769   std::string arg1_str(jarg1);
98770   arg1 = &arg1_str;
98771   argp2 = (Dali::ImageDimensions *)jarg2;
98772   if (!argp2) {
98773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98774     return 0;
98775   }
98776   arg2 = *argp2;
98777   arg3 = (Dali::FittingMode::Type)jarg3;
98778   arg4 = (Dali::SamplingMode::Type)jarg4;
98779   {
98780     try {
98781       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
98782     } catch (std::out_of_range& e) {
98783       {
98784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98785       };
98786     } catch (std::exception& e) {
98787       {
98788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98789       };
98790     } catch (...) {
98791       {
98792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98793       };
98794     }
98795   }
98796   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98797
98798   return jresult;
98799 }
98800
98801
98802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
98803   void * jresult ;
98804   std::string *arg1 = 0 ;
98805   Dali::ImageDimensions arg2 ;
98806   Dali::FittingMode::Type arg3 ;
98807   Dali::ImageDimensions *argp2 ;
98808   Dali::Devel::PixelBuffer result;
98809
98810   if (!jarg1) {
98811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98812     return 0;
98813   }
98814   std::string arg1_str(jarg1);
98815   arg1 = &arg1_str;
98816   argp2 = (Dali::ImageDimensions *)jarg2;
98817   if (!argp2) {
98818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98819     return 0;
98820   }
98821   arg2 = *argp2;
98822   arg3 = (Dali::FittingMode::Type)jarg3;
98823   {
98824     try {
98825       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
98826     } catch (std::out_of_range& e) {
98827       {
98828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98829       };
98830     } catch (std::exception& e) {
98831       {
98832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98833       };
98834     } catch (...) {
98835       {
98836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98837       };
98838     }
98839   }
98840   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98841
98842   return jresult;
98843 }
98844
98845
98846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
98847   void * jresult ;
98848   std::string *arg1 = 0 ;
98849   Dali::ImageDimensions arg2 ;
98850   Dali::ImageDimensions *argp2 ;
98851   Dali::Devel::PixelBuffer result;
98852
98853   if (!jarg1) {
98854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98855     return 0;
98856   }
98857   std::string arg1_str(jarg1);
98858   arg1 = &arg1_str;
98859   argp2 = (Dali::ImageDimensions *)jarg2;
98860   if (!argp2) {
98861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98862     return 0;
98863   }
98864   arg2 = *argp2;
98865   {
98866     try {
98867       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
98868     } catch (std::out_of_range& e) {
98869       {
98870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98871       };
98872     } catch (std::exception& e) {
98873       {
98874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98875       };
98876     } catch (...) {
98877       {
98878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98879       };
98880     }
98881   }
98882   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98883
98884   return jresult;
98885 }
98886
98887
98888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
98889   void * jresult ;
98890   std::string *arg1 = 0 ;
98891   Dali::Devel::PixelBuffer result;
98892
98893   if (!jarg1) {
98894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98895     return 0;
98896   }
98897   std::string arg1_str(jarg1);
98898   arg1 = &arg1_str;
98899   {
98900     try {
98901       result = Dali::LoadImageFromFile((std::string const &)*arg1);
98902     } catch (std::out_of_range& e) {
98903       {
98904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98905       };
98906     } catch (std::exception& e) {
98907       {
98908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98909       };
98910     } catch (...) {
98911       {
98912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98913       };
98914     }
98915   }
98916   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98917
98918   return jresult;
98919 }
98920
98921
98922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
98923   void * jresult ;
98924   std::string *arg1 = 0 ;
98925   Dali::ImageDimensions arg2 ;
98926   Dali::FittingMode::Type arg3 ;
98927   Dali::SamplingMode::Type arg4 ;
98928   bool arg5 ;
98929   Dali::ImageDimensions *argp2 ;
98930   Dali::ImageDimensions result;
98931
98932   if (!jarg1) {
98933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98934     return 0;
98935   }
98936   std::string arg1_str(jarg1);
98937   arg1 = &arg1_str;
98938   argp2 = (Dali::ImageDimensions *)jarg2;
98939   if (!argp2) {
98940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98941     return 0;
98942   }
98943   arg2 = *argp2;
98944   arg3 = (Dali::FittingMode::Type)jarg3;
98945   arg4 = (Dali::SamplingMode::Type)jarg4;
98946   arg5 = jarg5 ? true : false;
98947   {
98948     try {
98949       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
98950     } catch (std::out_of_range& e) {
98951       {
98952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98953       };
98954     } catch (std::exception& e) {
98955       {
98956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98957       };
98958     } catch (...) {
98959       {
98960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98961       };
98962     }
98963   }
98964   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
98965
98966   return jresult;
98967 }
98968
98969
98970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
98971   void * jresult ;
98972   std::string *arg1 = 0 ;
98973   Dali::ImageDimensions arg2 ;
98974   Dali::FittingMode::Type arg3 ;
98975   Dali::SamplingMode::Type arg4 ;
98976   Dali::ImageDimensions *argp2 ;
98977   Dali::ImageDimensions result;
98978
98979   if (!jarg1) {
98980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98981     return 0;
98982   }
98983   std::string arg1_str(jarg1);
98984   arg1 = &arg1_str;
98985   argp2 = (Dali::ImageDimensions *)jarg2;
98986   if (!argp2) {
98987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98988     return 0;
98989   }
98990   arg2 = *argp2;
98991   arg3 = (Dali::FittingMode::Type)jarg3;
98992   arg4 = (Dali::SamplingMode::Type)jarg4;
98993   {
98994     try {
98995       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
98996     } catch (std::out_of_range& e) {
98997       {
98998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98999       };
99000     } catch (std::exception& e) {
99001       {
99002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99003       };
99004     } catch (...) {
99005       {
99006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99007       };
99008     }
99009   }
99010   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
99011
99012   return jresult;
99013 }
99014
99015
99016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
99017   void * jresult ;
99018   std::string *arg1 = 0 ;
99019   Dali::ImageDimensions arg2 ;
99020   Dali::FittingMode::Type arg3 ;
99021   Dali::ImageDimensions *argp2 ;
99022   Dali::ImageDimensions result;
99023
99024   if (!jarg1) {
99025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99026     return 0;
99027   }
99028   std::string arg1_str(jarg1);
99029   arg1 = &arg1_str;
99030   argp2 = (Dali::ImageDimensions *)jarg2;
99031   if (!argp2) {
99032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99033     return 0;
99034   }
99035   arg2 = *argp2;
99036   arg3 = (Dali::FittingMode::Type)jarg3;
99037   {
99038     try {
99039       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
99040     } catch (std::out_of_range& e) {
99041       {
99042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99043       };
99044     } catch (std::exception& e) {
99045       {
99046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99047       };
99048     } catch (...) {
99049       {
99050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99051       };
99052     }
99053   }
99054   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
99055
99056   return jresult;
99057 }
99058
99059
99060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
99061   void * jresult ;
99062   std::string *arg1 = 0 ;
99063   Dali::ImageDimensions arg2 ;
99064   Dali::ImageDimensions *argp2 ;
99065   Dali::ImageDimensions result;
99066
99067   if (!jarg1) {
99068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99069     return 0;
99070   }
99071   std::string arg1_str(jarg1);
99072   arg1 = &arg1_str;
99073   argp2 = (Dali::ImageDimensions *)jarg2;
99074   if (!argp2) {
99075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99076     return 0;
99077   }
99078   arg2 = *argp2;
99079   {
99080     try {
99081       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
99082     } catch (std::out_of_range& e) {
99083       {
99084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99085       };
99086     } catch (std::exception& e) {
99087       {
99088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99089       };
99090     } catch (...) {
99091       {
99092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99093       };
99094     }
99095   }
99096   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
99097
99098   return jresult;
99099 }
99100
99101
99102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
99103   void * jresult ;
99104   std::string *arg1 = 0 ;
99105   Dali::ImageDimensions result;
99106
99107   if (!jarg1) {
99108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99109     return 0;
99110   }
99111   std::string arg1_str(jarg1);
99112   arg1 = &arg1_str;
99113   {
99114     try {
99115       result = Dali::GetClosestImageSize((std::string const &)*arg1);
99116     } catch (std::out_of_range& e) {
99117       {
99118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99119       };
99120     } catch (std::exception& e) {
99121       {
99122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99123       };
99124     } catch (...) {
99125       {
99126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99127       };
99128     }
99129   }
99130   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
99131
99132   return jresult;
99133 }
99134
99135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
99136   void * jresult ;
99137   std::string *arg1 = 0 ;
99138   Dali::ImageDimensions result;
99139
99140   if (!jarg1) {
99141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99142     return 0;
99143   }
99144   std::string arg1_str(jarg1);
99145   arg1 = &arg1_str;
99146   {
99147     try {
99148       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
99149     } catch (std::out_of_range& e) {
99150       {
99151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99152       };
99153     } catch (std::exception& e) {
99154       {
99155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99156       };
99157     } catch (...) {
99158       {
99159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99160       };
99161     }
99162   }
99163   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
99164
99165   return jresult;
99166 }
99167
99168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
99169   void * jresult ;
99170   std::string *arg1 = 0 ;
99171   Dali::ImageDimensions arg2 ;
99172   Dali::FittingMode::Type arg3 ;
99173   Dali::SamplingMode::Type arg4 ;
99174   bool arg5 ;
99175   Dali::ImageDimensions *argp2 ;
99176   Dali::Devel::PixelBuffer result;
99177
99178   if (!jarg1) {
99179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99180     return 0;
99181   }
99182   std::string arg1_str(jarg1);
99183   arg1 = &arg1_str;
99184   argp2 = (Dali::ImageDimensions *)jarg2;
99185   if (!argp2) {
99186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99187     return 0;
99188   }
99189   arg2 = *argp2;
99190   arg3 = (Dali::FittingMode::Type)jarg3;
99191   arg4 = (Dali::SamplingMode::Type)jarg4;
99192   arg5 = jarg5 ? true : false;
99193   {
99194     try {
99195       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
99196     } catch (std::out_of_range& e) {
99197       {
99198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99199       };
99200     } catch (std::exception& e) {
99201       {
99202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99203       };
99204     } catch (...) {
99205       {
99206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99207       };
99208     }
99209   }
99210   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
99211
99212   return jresult;
99213 }
99214
99215
99216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
99217   void * jresult ;
99218   std::string *arg1 = 0 ;
99219   Dali::ImageDimensions arg2 ;
99220   Dali::FittingMode::Type arg3 ;
99221   Dali::SamplingMode::Type arg4 ;
99222   Dali::ImageDimensions *argp2 ;
99223   Dali::Devel::PixelBuffer result;
99224
99225   if (!jarg1) {
99226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99227     return 0;
99228   }
99229   std::string arg1_str(jarg1);
99230   arg1 = &arg1_str;
99231   argp2 = (Dali::ImageDimensions *)jarg2;
99232   if (!argp2) {
99233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99234     return 0;
99235   }
99236   arg2 = *argp2;
99237   arg3 = (Dali::FittingMode::Type)jarg3;
99238   arg4 = (Dali::SamplingMode::Type)jarg4;
99239   {
99240     try {
99241       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
99242     } catch (std::out_of_range& e) {
99243       {
99244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99245       };
99246     } catch (std::exception& e) {
99247       {
99248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99249       };
99250     } catch (...) {
99251       {
99252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99253       };
99254     }
99255   }
99256   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
99257
99258   return jresult;
99259 }
99260
99261
99262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
99263   void * jresult ;
99264   std::string *arg1 = 0 ;
99265   Dali::ImageDimensions arg2 ;
99266   Dali::FittingMode::Type arg3 ;
99267   Dali::ImageDimensions *argp2 ;
99268   Dali::Devel::PixelBuffer result;
99269
99270   if (!jarg1) {
99271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99272     return 0;
99273   }
99274   std::string arg1_str(jarg1);
99275   arg1 = &arg1_str;
99276   argp2 = (Dali::ImageDimensions *)jarg2;
99277   if (!argp2) {
99278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99279     return 0;
99280   }
99281   arg2 = *argp2;
99282   arg3 = (Dali::FittingMode::Type)jarg3;
99283   {
99284     try {
99285       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
99286     } catch (std::out_of_range& e) {
99287       {
99288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99289       };
99290     } catch (std::exception& e) {
99291       {
99292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99293       };
99294     } catch (...) {
99295       {
99296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99297       };
99298     }
99299   }
99300   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
99301
99302   return jresult;
99303 }
99304
99305
99306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
99307   void * jresult ;
99308   std::string *arg1 = 0 ;
99309   Dali::ImageDimensions arg2 ;
99310   Dali::ImageDimensions *argp2 ;
99311   Dali::Devel::PixelBuffer result;
99312
99313   if (!jarg1) {
99314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99315     return 0;
99316   }
99317   std::string arg1_str(jarg1);
99318   arg1 = &arg1_str;
99319   argp2 = (Dali::ImageDimensions *)jarg2;
99320   if (!argp2) {
99321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99322     return 0;
99323   }
99324   arg2 = *argp2;
99325   {
99326     try {
99327       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
99328     } catch (std::out_of_range& e) {
99329       {
99330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99331       };
99332     } catch (std::exception& e) {
99333       {
99334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99335       };
99336     } catch (...) {
99337       {
99338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99339       };
99340     }
99341   }
99342   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
99343
99344   return jresult;
99345 }
99346
99347
99348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
99349   void * jresult ;
99350   std::string *arg1 = 0 ;
99351   Dali::Devel::PixelBuffer result;
99352
99353   if (!jarg1) {
99354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99355     return 0;
99356   }
99357   std::string arg1_str(jarg1);
99358   arg1 = &arg1_str;
99359   {
99360     try {
99361       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
99362     } catch (std::out_of_range& e) {
99363       {
99364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99365       };
99366     } catch (std::exception& e) {
99367       {
99368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99369       };
99370     } catch (...) {
99371       {
99372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99373       };
99374     }
99375   }
99376   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
99377
99378   return jresult;
99379 }
99380
99381
99382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
99383   void * jresult ;
99384   Dali::Toolkit::WebView result;
99385
99386   {
99387     try {
99388       result = Dali::Toolkit::WebView::New();
99389     } catch (std::out_of_range& e) {
99390       {
99391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99392       };
99393     } catch (std::exception& e) {
99394       {
99395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99396       };
99397     } catch (Dali::DaliException e) {
99398       {
99399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99400       };
99401     } catch (...) {
99402       {
99403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99404       };
99405     }
99406   }
99407   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
99408   return jresult;
99409 }
99410
99411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
99412   void * jresult ;
99413   Dali::Toolkit::WebView result;
99414
99415   std::string *arg1;
99416   std::string *arg2;
99417
99418   if (!jarg1) {
99419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
99420     return 0;
99421   }
99422   if (!jarg2) {
99423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
99424     return 0;
99425   }
99426
99427   std::string jarg1_str = std::string(jarg1);
99428   std::string jarg2_str = std::string(jarg2);
99429
99430   arg1 = &jarg1_str;
99431   arg2 = &jarg2_str;
99432
99433   {
99434     try {
99435       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
99436     } catch (std::out_of_range& e) {
99437       {
99438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99439       };
99440     } catch (std::exception& e) {
99441       {
99442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99443       };
99444     } catch (Dali::DaliException e) {
99445       {
99446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99447       };
99448     } catch (...) {
99449       {
99450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99451       };
99452     }
99453   }
99454   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
99455   return jresult;
99456 }
99457
99458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
99459   void * jresult ;
99460   Dali::Toolkit::WebView *arg1 = 0 ;
99461   Dali::Toolkit::WebView *result = 0 ;
99462
99463   arg1 = (Dali::Toolkit::WebView *)jarg1;
99464   if (!arg1) {
99465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
99466     return 0;
99467   }
99468   {
99469     try {
99470       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
99471     } catch (std::out_of_range& e) {
99472       {
99473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99474       };
99475     } catch (std::exception& e) {
99476       {
99477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99478       };
99479     } catch (Dali::DaliException e) {
99480       {
99481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99482       };
99483     } catch (...) {
99484       {
99485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99486       };
99487     }
99488   }
99489   jresult = (void *)result;
99490   return jresult;
99491 }
99492
99493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
99494   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99495   arg1 = (Dali::Toolkit::WebView *)jarg1;
99496   {
99497     try {
99498       delete arg1;
99499     } catch (std::out_of_range& e) {
99500       {
99501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99502       };
99503     } catch (std::exception& e) {
99504       {
99505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99506       };
99507     } catch (Dali::DaliException e) {
99508       {
99509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99510       };
99511     } catch (...) {
99512       {
99513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99514       };
99515     }
99516   }
99517 }
99518
99519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
99520   void * jresult ;
99521   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99522   Dali::Toolkit::WebView *arg2 = 0 ;
99523   Dali::Toolkit::WebView *result = 0 ;
99524
99525   arg1 = (Dali::Toolkit::WebView *)jarg1;
99526   arg2 = (Dali::Toolkit::WebView *)jarg2;
99527   if (!arg2) {
99528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
99529     return 0;
99530   }
99531   {
99532     try {
99533       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
99534     } catch (std::out_of_range& e) {
99535       {
99536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99537       };
99538     } catch (std::exception& e) {
99539       {
99540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99541       };
99542     } catch (Dali::DaliException e) {
99543       {
99544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99545       };
99546     } catch (...) {
99547       {
99548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99549       };
99550     }
99551   }
99552   jresult = (void *)result;
99553   return jresult;
99554 }
99555
99556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
99557   void * jresult ;
99558   Dali::BaseHandle arg1 ;
99559   Dali::BaseHandle *argp1 ;
99560   Dali::Toolkit::WebView result;
99561
99562   argp1 = (Dali::BaseHandle *)jarg1;
99563   if (!argp1) {
99564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
99565     return 0;
99566   }
99567   arg1 = *argp1;
99568   {
99569     try {
99570       result = Dali::Toolkit::WebView::DownCast(arg1);
99571     } catch (std::out_of_range& e) {
99572       {
99573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99574       };
99575     } catch (std::exception& e) {
99576       {
99577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99578       };
99579     } catch (Dali::DaliException e) {
99580       {
99581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99582       };
99583     } catch (...) {
99584       {
99585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99586       };
99587     }
99588   }
99589   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
99590   return jresult;
99591 }
99592
99593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
99594   return (int) Dali::Toolkit::WebView::Property::URL;
99595 }
99596
99597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
99598   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
99599 }
99600
99601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
99602   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
99603 }
99604
99605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
99606   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
99607 }
99608
99609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
99610   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
99611 }
99612
99613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
99614   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
99615 }
99616
99617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
99618   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
99619 }
99620
99621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
99622   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
99623 }
99624
99625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
99626   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99627   std::string *arg2;
99628
99629   arg1 = (Dali::Toolkit::WebView *)jarg1;
99630
99631   if (!jarg2) {
99632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99633     return;
99634   }
99635
99636   std::string jarg2str = std::string(jarg2);
99637   arg2 = &jarg2str;
99638   {
99639     try {
99640       (arg1)->LoadUrl((std::string const &)*arg2);
99641     } catch (std::out_of_range& e) {
99642       {
99643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99644       };
99645     } catch (std::exception& e) {
99646       {
99647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99648       };
99649     } catch (Dali::DaliException e) {
99650       {
99651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99652       };
99653     } catch (...) {
99654       {
99655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99656       };
99657     }
99658   }
99659 }
99660
99661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
99662   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99663   std::string *arg2;
99664
99665   arg1 = (Dali::Toolkit::WebView *)jarg1;
99666   if (!jarg2) {
99667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99668     return;
99669   }
99670   std::string jarg2str = std::string(jarg2);
99671   arg2 = &jarg2str;
99672   {
99673     try {
99674       (arg1)->LoadHTMLString((std::string const &)*arg2);
99675     } catch (std::out_of_range& e) {
99676       {
99677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99678       };
99679     } catch (std::exception& e) {
99680       {
99681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99682       };
99683     } catch (Dali::DaliException e) {
99684       {
99685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99686       };
99687     } catch (...) {
99688       {
99689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99690       };
99691     }
99692   }
99693 }
99694
99695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
99696   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99697
99698   arg1 = (Dali::Toolkit::WebView *)jarg1;
99699   {
99700     try {
99701       (arg1)->Reload();
99702     } catch (std::out_of_range& e) {
99703       {
99704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99705       };
99706     } catch (std::exception& e) {
99707       {
99708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99709       };
99710     } catch (Dali::DaliException e) {
99711       {
99712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99713       };
99714     } catch (...) {
99715       {
99716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99717       };
99718     }
99719   }
99720 }
99721
99722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
99723   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99724
99725   arg1 = (Dali::Toolkit::WebView *)jarg1;
99726   {
99727     try {
99728       (arg1)->StopLoading();
99729     } catch (std::out_of_range& e) {
99730       {
99731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99732       };
99733     } catch (std::exception& e) {
99734       {
99735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99736       };
99737     } catch (Dali::DaliException e) {
99738       {
99739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99740       };
99741     } catch (...) {
99742       {
99743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99744       };
99745     }
99746   }
99747 }
99748
99749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
99750   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99751
99752   arg1 = (Dali::Toolkit::WebView *)jarg1;
99753   {
99754     try {
99755       (arg1)->Suspend();
99756     } catch (std::out_of_range& e) {
99757       {
99758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99759       };
99760     } catch (std::exception& e) {
99761       {
99762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99763       };
99764     } catch (Dali::DaliException e) {
99765       {
99766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99767       };
99768     } catch (...) {
99769       {
99770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99771       };
99772     }
99773   }
99774 }
99775
99776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
99777   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99778
99779   arg1 = (Dali::Toolkit::WebView *)jarg1;
99780   {
99781     try {
99782       (arg1)->Resume();
99783     } catch (std::out_of_range& e) {
99784       {
99785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99786       };
99787     } catch (std::exception& e) {
99788       {
99789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99790       };
99791     } catch (Dali::DaliException e) {
99792       {
99793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99794       };
99795     } catch (...) {
99796       {
99797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99798       };
99799     }
99800   }
99801 }
99802
99803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
99804   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99805
99806   arg1 = (Dali::Toolkit::WebView *)jarg1;
99807   {
99808     try {
99809       (arg1)->GoBack();
99810     } catch (std::out_of_range& e) {
99811       {
99812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99813       };
99814     } catch (std::exception& e) {
99815       {
99816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99817       };
99818     } catch (Dali::DaliException e) {
99819       {
99820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99821       };
99822     } catch (...) {
99823       {
99824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99825       };
99826     }
99827   }
99828 }
99829
99830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
99831   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99832
99833   arg1 = (Dali::Toolkit::WebView *)jarg1;
99834   {
99835     try {
99836       (arg1)->GoForward();
99837     } catch (std::out_of_range& e) {
99838       {
99839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99840       };
99841     } catch (std::exception& e) {
99842       {
99843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99844       };
99845     } catch (Dali::DaliException e) {
99846       {
99847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99848       };
99849     } catch (...) {
99850       {
99851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99852       };
99853     }
99854   }
99855 }
99856
99857 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
99858   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99859   bool ret;
99860
99861   arg1 = (Dali::Toolkit::WebView *)jarg1;
99862   {
99863     try {
99864       ret = (arg1)->CanGoBack();
99865     } catch (std::out_of_range& e) {
99866       {
99867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
99868       };
99869     } catch (std::exception& e) {
99870       {
99871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
99872       };
99873     } catch (Dali::DaliException e) {
99874       {
99875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
99876       };
99877     } catch (...) {
99878       {
99879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
99880       };
99881     }
99882   }
99883   return ret;
99884 }
99885
99886 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
99887   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99888   bool ret;
99889
99890   arg1 = (Dali::Toolkit::WebView *)jarg1;
99891   {
99892     try {
99893       ret = (arg1)->CanGoForward();
99894     } catch (std::out_of_range& e) {
99895       {
99896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
99897       };
99898     } catch (std::exception& e) {
99899       {
99900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
99901       };
99902     } catch (Dali::DaliException e) {
99903       {
99904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
99905       };
99906     } catch (...) {
99907       {
99908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
99909       };
99910     }
99911   }
99912   return ret;
99913 }
99914
99915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
99916   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99917   std::string *arg2;
99918
99919   arg1 = (Dali::Toolkit::WebView *)jarg1;
99920   if (!jarg2) {
99921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99922     return;
99923   }
99924   std::string jarg2_str = std::string(jarg2);
99925   arg2 = &jarg2_str;
99926
99927   {
99928     try {
99929       if (jarg3) {
99930         void (*handler)(char*) = (void (*)(char*)) jarg3;
99931         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
99932           handler(SWIG_csharp_string_callback(result.c_str()));
99933         });
99934       } else {
99935         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
99936       }
99937     } catch (std::out_of_range& e) {
99938       {
99939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99940       };
99941     } catch (std::exception& e) {
99942       {
99943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99944       };
99945     } catch (Dali::DaliException e) {
99946       {
99947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99948       };
99949     } catch (...) {
99950       {
99951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99952       };
99953     }
99954   }
99955 }
99956
99957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
99958 {
99959   if (!jarg2) {
99960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99961     return;
99962   }
99963
99964   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
99965   std::string exposedObjectName = jarg2;
99966   void (*handler)(char*) = (void (*)(char*)) jarg3;
99967
99968   {
99969     try {
99970       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
99971         handler(SWIG_csharp_string_callback(message.c_str()));
99972       });
99973     } catch (std::out_of_range& e) {
99974       {
99975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99976       };
99977     } catch (std::exception& e) {
99978       {
99979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99980       };
99981     } catch (Dali::DaliException e) {
99982       {
99983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99984       };
99985     } catch (...) {
99986       {
99987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99988       };
99989     }
99990   }
99991 }
99992
99993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
99994   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99995
99996   arg1 = (Dali::Toolkit::WebView *)jarg1;
99997   {
99998     try {
99999       (arg1)->ClearHistory();
100000     } catch (std::out_of_range& e) {
100001       {
100002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100003       };
100004     } catch (std::exception& e) {
100005       {
100006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100007       };
100008     } catch (Dali::DaliException e) {
100009       {
100010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100011       };
100012     } catch (...) {
100013       {
100014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100015       };
100016     }
100017   }
100018 }
100019
100020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
100021   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100022
100023   arg1 = (Dali::Toolkit::WebView *)jarg1;
100024   {
100025     try {
100026       (arg1)->ClearCache();
100027     } catch (std::out_of_range& e) {
100028       {
100029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100030       };
100031     } catch (std::exception& e) {
100032       {
100033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100034       };
100035     } catch (Dali::DaliException e) {
100036       {
100037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100038       };
100039     } catch (...) {
100040       {
100041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100042       };
100043     }
100044   }
100045 }
100046
100047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
100048   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100049
100050   arg1 = (Dali::Toolkit::WebView *)jarg1;
100051   {
100052     try {
100053       (arg1)->ClearCookies();
100054     } catch (std::out_of_range& e) {
100055       {
100056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100057       };
100058     } catch (std::exception& e) {
100059       {
100060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100061       };
100062     } catch (Dali::DaliException e) {
100063       {
100064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100065       };
100066     } catch (...) {
100067       {
100068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100069       };
100070     }
100071   }
100072 }
100073
100074 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
100075     return (Dali::Toolkit::Control *)jarg1;
100076 }
100077
100078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
100079   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
100080   SignalConverter::WebViewPageLoadSignal* result = NULL;
100081   {
100082     try {
100083       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
100084     } catch (std::out_of_range& e) {
100085       {
100086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100087       };
100088     } catch (std::exception& e) {
100089       {
100090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100091       };
100092     } catch (Dali::DaliException e) {
100093       {
100094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100095       };
100096     } catch (...) {
100097       {
100098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100099       };
100100     }
100101   }
100102   return (void*) result;
100103 }
100104
100105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
100106   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
100107   SignalConverter::WebViewPageLoadSignal* result = NULL;
100108   {
100109     try {
100110       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
100111     } catch (std::out_of_range& e) {
100112       {
100113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100114       };
100115     } catch (std::exception& e) {
100116       {
100117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100118       };
100119     } catch (Dali::DaliException e) {
100120       {
100121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100122       };
100123     } catch (...) {
100124       {
100125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100126       };
100127     }
100128   }
100129   return (void*) result;
100130 }
100131
100132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
100133 {
100134   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
100135   {
100136     try {
100137       delete object;
100138     } catch (std::out_of_range& e) {
100139       {
100140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100141       };
100142     } catch (std::exception& e) {
100143       {
100144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100145       };
100146     } catch (Dali::DaliException e) {
100147       {
100148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100149       };
100150     } catch (...) {
100151       {
100152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100153       };
100154     }
100155   }
100156 }
100157
100158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
100159 {
100160   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
100161   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
100162   {
100163     try {
100164       proxy->Connect(callback);
100165     } catch (std::out_of_range& e) {
100166       {
100167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100168       };
100169     } catch (std::exception& e) {
100170       {
100171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100172       };
100173     } catch (Dali::DaliException e) {
100174       {
100175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100176       };
100177     } catch (...) {
100178       {
100179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100180       };
100181     }
100182   }
100183 }
100184
100185
100186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
100187   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
100188   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
100189   {
100190     try {
100191       proxy->Disconnect(callback);
100192     } catch (std::out_of_range& e) {
100193       {
100194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100195       };
100196     } catch (std::exception& e) {
100197       {
100198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100199       };
100200     } catch (Dali::DaliException e) {
100201       {
100202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100203       };
100204     } catch (...) {
100205       {
100206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100207       };
100208     }
100209   }
100210 }
100211
100212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
100213   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
100214   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
100215   {
100216     try {
100217       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
100218     } catch (std::out_of_range& e) {
100219       {
100220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100221       };
100222     } catch (std::exception& e) {
100223       {
100224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100225       };
100226     } catch (Dali::DaliException e) {
100227       {
100228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100229       };
100230     } catch (...) {
100231       {
100232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100233       };
100234     }
100235   }
100236   return (void*) result;
100237 }
100238
100239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
100240 {
100241   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
100242   {
100243     try {
100244       delete object;
100245     } catch (std::out_of_range& e) {
100246       {
100247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100248       };
100249     } catch (std::exception& e) {
100250       {
100251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100252       };
100253     } catch (Dali::DaliException e) {
100254       {
100255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100256       };
100257     } catch (...) {
100258       {
100259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100260       };
100261     }
100262   }
100263 }
100264
100265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
100266 {
100267   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
100268   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
100269   {
100270     try {
100271       proxy->Connect(callback);
100272     } catch (std::out_of_range& e) {
100273       {
100274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100275       };
100276     } catch (std::exception& e) {
100277       {
100278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100279       };
100280     } catch (Dali::DaliException e) {
100281       {
100282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100283       };
100284     } catch (...) {
100285       {
100286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100287       };
100288     }
100289   }
100290 }
100291
100292
100293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
100294   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
100295   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
100296   {
100297     try {
100298       proxy->Disconnect(callback);
100299     } catch (std::out_of_range& e) {
100300       {
100301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100302       };
100303     } catch (std::exception& e) {
100304       {
100305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100306       };
100307     } catch (Dali::DaliException e) {
100308       {
100309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100310       };
100311     } catch (...) {
100312       {
100313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100314       };
100315     }
100316   }
100317 }
100318
100319 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
100320   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
100321   char * jresult = SWIG_csharp_string_callback((const char *)result);
100322   return jresult;
100323 }
100324
100325 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
100326   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
100327   return result;
100328 }
100329
100330
100331 struct NativeImageSourcePtrHandle
100332 {
100333   NativeImageSourcePtr Ptr;
100334 };
100335
100336 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
100337 {
100338   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
100339   return (NativeImageInterface*)(arg1);
100340 }
100341
100342 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
100343 {
100344   void* jresult;
100345   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
100346   {
100347     try {
100348       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
100349     }
100350     catch (std::out_of_range & e) {
100351       {
100352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100353       };
100354     }
100355     catch (std::exception & e) {
100356       {
100357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100358       };
100359     }
100360     catch (Dali::DaliException e) {
100361       {
100362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100363       };
100364     }
100365     catch (...) {
100366       {
100367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100368       };
100369     }
100370   }
100371   jresult = (void *)handle;
100372   return jresult;
100373 }
100374
100375 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
100376 {
100377   void* jresult;
100378   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
100379   jresult = (void*)( handle->Ptr.Get() );
100380   return jresult;
100381 }
100382
100383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
100384   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
100385   {
100386     try {
100387       delete arg1;
100388     }
100389     catch (std::out_of_range & e) {
100390       {
100391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
100392       };
100393     }
100394     catch (std::exception & e) {
100395       {
100396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
100397       };
100398     }
100399     catch (Dali::DaliException e) {
100400       {
100401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
100402       };
100403     }
100404     catch (...) {
100405       {
100406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
100407       };
100408     }
100409   }
100410 }
100411
100412 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
100413 {
100414   void* jresult;
100415   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
100416   uint16_t* arg2 = (uint16_t*)(jarg2);
100417   uint16_t* arg3 = (uint16_t*)(jarg3);
100418   uint16_t* arg4 = (uint16_t*)(jarg4);
100419   {
100420     try {
100421       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
100422     }
100423     catch (std::out_of_range & e) {
100424       {
100425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100426       };
100427     }
100428     catch (std::exception & e) {
100429       {
100430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100431       };
100432     }
100433     catch (Dali::DaliException e) {
100434       {
100435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100436       };
100437     }
100438     catch (...) {
100439       {
100440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100441       };
100442     }
100443   }
100444   return jresult;
100445 }
100446
100447 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
100448 {
100449   bool jresult;
100450   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
100451
100452   {
100453     try {
100454       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
100455     }
100456     catch (std::out_of_range & e) {
100457       {
100458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100459       };
100460     }
100461     catch (std::exception & e) {
100462       {
100463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100464       };
100465     }
100466     catch (Dali::DaliException e) {
100467       {
100468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100469       };
100470     }
100471     catch (...) {
100472       {
100473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100474       };
100475     }
100476   }
100477   return jresult;
100478 }
100479
100480
100481 #ifdef __cplusplus
100482 }
100483 #endif
100484